structs-0.go

// Copyright 2023 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/*
Package exampleocconfig is a generated package which contains definitions
of structs which represent a YANG schema. The generated schema can be
compressed by a series of transformations (compression was true
in this case).

This package was generated by ygnmi version: (devel): (ygot: v0.29.20)
using the following YANG input files:
  - ../../pathgen/testdata/yang/openconfig-simple.yang
  - ../../pathgen/testdata/yang/openconfig-withlistval.yang
  - ../../pathgen/testdata/yang/openconfig-nested.yang

Imported modules were sourced from:
*/
package exampleocconfig

import (
	"encoding/json"
	"fmt"
	"reflect"

	"github.com/openconfig/goyang/pkg/yang"
	"github.com/openconfig/ygot/ygot"
	"github.com/openconfig/ygot/ytypes"
)

// Binary is a type that is used for fields that have a YANG type of
// binary. It is used such that binary fields can be distinguished from
// leaf-lists of uint8s (which are mapped to []uint8, equivalent to
// []byte in reflection).
type Binary []byte

// YANGEmpty is a type that is used for fields that have a YANG type of
// empty. It is used such that empty fields can be distinguished from boolean fields
// in the generated code.
type YANGEmpty bool

// UnionInt8 is an int8 type assignable to unions of which it is a subtype.
type UnionInt8 int8

// UnionInt16 is an int16 type assignable to unions of which it is a subtype.
type UnionInt16 int16

// UnionInt32 is an int32 type assignable to unions of which it is a subtype.
type UnionInt32 int32

// UnionInt64 is an int64 type assignable to unions of which it is a subtype.
type UnionInt64 int64

// UnionUint8 is a uint8 type assignable to unions of which it is a subtype.
type UnionUint8 uint8

// UnionUint16 is a uint16 type assignable to unions of which it is a subtype.
type UnionUint16 uint16

// UnionUint32 is a uint32 type assignable to unions of which it is a subtype.
type UnionUint32 uint32

// UnionUint64 is a uint64 type assignable to unions of which it is a subtype.
type UnionUint64 uint64

// UnionFloat64 is a float64 type assignable to unions of which it is a subtype.
type UnionFloat64 float64

// UnionString is a string type assignable to unions of which it is a subtype.
type UnionString string

// UnionBool is a bool type assignable to unions of which it is a subtype.
type UnionBool bool

// UnionUnsupported is an interface{} wrapper type for unsupported types. It is
// assignable to unions of which it is a subtype.
type UnionUnsupported struct {
	Value interface{}
}

var (
	SchemaTree map[string]*yang.Entry
	ΛEnumTypes map[string][]reflect.Type
)

func init() {
	var err error
	initΛEnumTypes()
	if SchemaTree, err = UnzipSchema(); err != nil {
		panic("schema error: " + err.Error())
	}
}

// Schema returns the details of the generated schema.
func Schema() (*ytypes.Schema, error) {
	uzp, err := UnzipSchema()
	if err != nil {
		return nil, fmt.Errorf("cannot unzip schema, %v", err)
	}

	return &ytypes.Schema{
		Root:       &Root{},
		SchemaTree: uzp,
		Unmarshal:  Unmarshal,
	}, nil
}

// UnzipSchema unzips the zipped schema and returns a map of yang.Entry nodes,
// keyed by the name of the struct that the yang.Entry describes the schema for.
func UnzipSchema() (map[string]*yang.Entry, error) {
	var schemaTree map[string]*yang.Entry
	var err error
	if schemaTree, err = ygot.GzipToSchema(ySchema); err != nil {
		return nil, fmt.Errorf("could not unzip the schema; %v", err)
	}
	return schemaTree, nil
}

// Unmarshal unmarshals data, which must be RFC7951 JSON format, into
// destStruct, which must be non-nil and the correct GoStruct type. It returns
// an error if the destStruct is not found in the schema or the data cannot be
// unmarshaled. The supplied options (opts) are used to control the behaviour
// of the unmarshal function - for example, determining whether errors are
// thrown for unknown fields in the input JSON.
func Unmarshal(data []byte, destStruct ygot.GoStruct, opts ...ytypes.UnmarshalOpt) error {
	tn := reflect.TypeOf(destStruct).Elem().Name()
	schema, ok := SchemaTree[tn]
	if !ok {
		return fmt.Errorf("could not find schema for type %s", tn)
	}
	var jsonTree interface{}
	if err := json.Unmarshal([]byte(data), &jsonTree); err != nil {
		return err
	}
	return ytypes.Unmarshal(schema, destStruct, jsonTree, opts...)
}

// A represents the /openconfig-nested/a YANG schema element.
type A struct {
	B *A_B `path:"b" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A) IsYANGGoStruct() {}

// GetOrCreateB retrieves the value of the B field
// or returns the existing field if it already exists.
func (t *A) GetOrCreateB() *A_B {
	if t.B != nil {
		return t.B
	}
	t.B = &A_B{}
	return t.B
}

// GetB returns the value of the B struct pointer
// from A. If the receiver or the field B is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A) GetB() *A_B {
	if t != nil && t.B != nil {
		return t.B
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.B.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A.
func (*A) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B represents the /openconfig-nested/a/b YANG schema element.
type A_B struct {
	C *A_B_C `path:"c" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B) IsYANGGoStruct() {}

// GetOrCreateC retrieves the value of the C field
// or returns the existing field if it already exists.
func (t *A_B) GetOrCreateC() *A_B_C {
	if t.C != nil {
		return t.C
	}
	t.C = &A_B_C{}
	return t.C
}

// GetC returns the value of the C struct pointer
// from A_B. If the receiver or the field C is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B) GetC() *A_B_C {
	if t != nil && t.C != nil {
		return t.C
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.C.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B.
func (*A_B) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C represents the /openconfig-nested/a/b/c YANG schema element.
type A_B_C struct {
	D *A_B_C_D `path:"d" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C) IsYANGGoStruct() {}

// GetOrCreateD retrieves the value of the D field
// or returns the existing field if it already exists.
func (t *A_B_C) GetOrCreateD() *A_B_C_D {
	if t.D != nil {
		return t.D
	}
	t.D = &A_B_C_D{}
	return t.D
}

// GetD returns the value of the D struct pointer
// from A_B_C. If the receiver or the field D is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C) GetD() *A_B_C_D {
	if t != nil && t.D != nil {
		return t.D
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.D.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C.
func (*A_B_C) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D represents the /openconfig-nested/a/b/c/d YANG schema element.
type A_B_C_D struct {
	E *A_B_C_D_E `path:"e" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D) IsYANGGoStruct() {}

// GetOrCreateE retrieves the value of the E field
// or returns the existing field if it already exists.
func (t *A_B_C_D) GetOrCreateE() *A_B_C_D_E {
	if t.E != nil {
		return t.E
	}
	t.E = &A_B_C_D_E{}
	return t.E
}

// GetE returns the value of the E struct pointer
// from A_B_C_D. If the receiver or the field E is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D) GetE() *A_B_C_D_E {
	if t != nil && t.E != nil {
		return t.E
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.E.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D.
func (*A_B_C_D) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E represents the /openconfig-nested/a/b/c/d/e YANG schema element.
type A_B_C_D_E struct {
	F *A_B_C_D_E_F `path:"f" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E) IsYANGGoStruct() {}

// GetOrCreateF retrieves the value of the F field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E) GetOrCreateF() *A_B_C_D_E_F {
	if t.F != nil {
		return t.F
	}
	t.F = &A_B_C_D_E_F{}
	return t.F
}

// GetF returns the value of the F struct pointer
// from A_B_C_D_E. If the receiver or the field F is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E) GetF() *A_B_C_D_E_F {
	if t != nil && t.F != nil {
		return t.F
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.F.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E.
func (*A_B_C_D_E) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F represents the /openconfig-nested/a/b/c/d/e/f YANG schema element.
type A_B_C_D_E_F struct {
	G *A_B_C_D_E_F_G `path:"g" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F) IsYANGGoStruct() {}

// GetOrCreateG retrieves the value of the G field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F) GetOrCreateG() *A_B_C_D_E_F_G {
	if t.G != nil {
		return t.G
	}
	t.G = &A_B_C_D_E_F_G{}
	return t.G
}

// GetG returns the value of the G struct pointer
// from A_B_C_D_E_F. If the receiver or the field G is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F) GetG() *A_B_C_D_E_F_G {
	if t != nil && t.G != nil {
		return t.G
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.G.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F.
func (*A_B_C_D_E_F) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G represents the /openconfig-nested/a/b/c/d/e/f/g YANG schema element.
type A_B_C_D_E_F_G struct {
	H *A_B_C_D_E_F_G_H `path:"h" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G) IsYANGGoStruct() {}

// GetOrCreateH retrieves the value of the H field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F_G) GetOrCreateH() *A_B_C_D_E_F_G_H {
	if t.H != nil {
		return t.H
	}
	t.H = &A_B_C_D_E_F_G_H{}
	return t.H
}

// GetH returns the value of the H struct pointer
// from A_B_C_D_E_F_G. If the receiver or the field H is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F_G) GetH() *A_B_C_D_E_F_G_H {
	if t != nil && t.H != nil {
		return t.H
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.H.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G.
func (*A_B_C_D_E_F_G) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G_H represents the /openconfig-nested/a/b/c/d/e/f/g/h YANG schema element.
type A_B_C_D_E_F_G_H struct {
	I *A_B_C_D_E_F_G_H_I `path:"i" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G_H implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G_H) IsYANGGoStruct() {}

// GetOrCreateI retrieves the value of the I field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F_G_H) GetOrCreateI() *A_B_C_D_E_F_G_H_I {
	if t.I != nil {
		return t.I
	}
	t.I = &A_B_C_D_E_F_G_H_I{}
	return t.I
}

// GetI returns the value of the I struct pointer
// from A_B_C_D_E_F_G_H. If the receiver or the field I is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F_G_H) GetI() *A_B_C_D_E_F_G_H_I {
	if t != nil && t.I != nil {
		return t.I
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G_H
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G_H) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.I.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G_H"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G_H) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G_H.
func (*A_B_C_D_E_F_G_H) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G_H_I represents the /openconfig-nested/a/b/c/d/e/f/g/h/i YANG schema element.
type A_B_C_D_E_F_G_H_I struct {
	J *A_B_C_D_E_F_G_H_I_J `path:"j" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G_H_I implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G_H_I) IsYANGGoStruct() {}

// GetOrCreateJ retrieves the value of the J field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F_G_H_I) GetOrCreateJ() *A_B_C_D_E_F_G_H_I_J {
	if t.J != nil {
		return t.J
	}
	t.J = &A_B_C_D_E_F_G_H_I_J{}
	return t.J
}

// GetJ returns the value of the J struct pointer
// from A_B_C_D_E_F_G_H_I. If the receiver or the field J is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F_G_H_I) GetJ() *A_B_C_D_E_F_G_H_I_J {
	if t != nil && t.J != nil {
		return t.J
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G_H_I
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G_H_I) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.J.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G_H_I"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G_H_I) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G_H_I.
func (*A_B_C_D_E_F_G_H_I) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G_H_I_J represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j YANG schema element.
type A_B_C_D_E_F_G_H_I_J struct {
	K *A_B_C_D_E_F_G_H_I_J_K `path:"k" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G_H_I_J implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G_H_I_J) IsYANGGoStruct() {}

// GetOrCreateK retrieves the value of the K field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F_G_H_I_J) GetOrCreateK() *A_B_C_D_E_F_G_H_I_J_K {
	if t.K != nil {
		return t.K
	}
	t.K = &A_B_C_D_E_F_G_H_I_J_K{}
	return t.K
}

// GetK returns the value of the K struct pointer
// from A_B_C_D_E_F_G_H_I_J. If the receiver or the field K is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F_G_H_I_J) GetK() *A_B_C_D_E_F_G_H_I_J_K {
	if t != nil && t.K != nil {
		return t.K
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G_H_I_J
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G_H_I_J) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.K.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G_H_I_J"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G_H_I_J) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G_H_I_J.
func (*A_B_C_D_E_F_G_H_I_J) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G_H_I_J_K represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K struct {
	L *A_B_C_D_E_F_G_H_I_J_K_L `path:"l" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G_H_I_J_K implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G_H_I_J_K) IsYANGGoStruct() {}

// GetOrCreateL retrieves the value of the L field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F_G_H_I_J_K) GetOrCreateL() *A_B_C_D_E_F_G_H_I_J_K_L {
	if t.L != nil {
		return t.L
	}
	t.L = &A_B_C_D_E_F_G_H_I_J_K_L{}
	return t.L
}

// GetL returns the value of the L struct pointer
// from A_B_C_D_E_F_G_H_I_J_K. If the receiver or the field L is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F_G_H_I_J_K) GetL() *A_B_C_D_E_F_G_H_I_J_K_L {
	if t != nil && t.L != nil {
		return t.L
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G_H_I_J_K
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G_H_I_J_K) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.L.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J_K) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G_H_I_J_K"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J_K) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G_H_I_J_K) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G_H_I_J_K.
func (*A_B_C_D_E_F_G_H_I_J_K) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G_H_I_J_K_L represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_L struct {
	M *A_B_C_D_E_F_G_H_I_J_K_L_M `path:"m" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G_H_I_J_K_L implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G_H_I_J_K_L) IsYANGGoStruct() {}

// GetOrCreateM retrieves the value of the M field
// or returns the existing field if it already exists.
func (t *A_B_C_D_E_F_G_H_I_J_K_L) GetOrCreateM() *A_B_C_D_E_F_G_H_I_J_K_L_M {
	if t.M != nil {
		return t.M
	}
	t.M = &A_B_C_D_E_F_G_H_I_J_K_L_M{}
	return t.M
}

// GetM returns the value of the M struct pointer
// from A_B_C_D_E_F_G_H_I_J_K_L. If the receiver or the field M is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *A_B_C_D_E_F_G_H_I_J_K_L) GetM() *A_B_C_D_E_F_G_H_I_J_K_L_M {
	if t != nil && t.M != nil {
		return t.M
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G_H_I_J_K_L
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G_H_I_J_K_L) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.M.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J_K_L) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G_H_I_J_K_L"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J_K_L) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G_H_I_J_K_L) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G_H_I_J_K_L.
func (*A_B_C_D_E_F_G_H_I_J_K_L) ΛBelongingModule() string {
	return "openconfig-nested"
}

// A_B_C_D_E_F_G_H_I_J_K_L_M represents the /openconfig-nested/a/b/c/d/e/f/g/h/i/j/k/l/m YANG schema element.
type A_B_C_D_E_F_G_H_I_J_K_L_M struct {
	Foo *string `path:"state/foo" module:"openconfig-nested/openconfig-nested"`
}

// IsYANGGoStruct ensures that A_B_C_D_E_F_G_H_I_J_K_L_M implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*A_B_C_D_E_F_G_H_I_J_K_L_M) IsYANGGoStruct() {}

// GetFoo retrieves the value of the leaf Foo from the A_B_C_D_E_F_G_H_I_J_K_L_M
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Foo is set, it can
// safely use t.GetFoo() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Foo == nil' before retrieving the leaf's value.
func (t *A_B_C_D_E_F_G_H_I_J_K_L_M) GetFoo() string {
	if t == nil || t.Foo == nil {
		return ""
	}
	return *t.Foo
}

// SetFoo sets the value of the leaf Foo in the A_B_C_D_E_F_G_H_I_J_K_L_M
// struct.
func (t *A_B_C_D_E_F_G_H_I_J_K_L_M) SetFoo(v string) {
	t.Foo = &v
}

// PopulateDefaults recursively populates unset leaf fields in the A_B_C_D_E_F_G_H_I_J_K_L_M
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *A_B_C_D_E_F_G_H_I_J_K_L_M) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J_K_L_M) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["A_B_C_D_E_F_G_H_I_J_K_L_M"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *A_B_C_D_E_F_G_H_I_J_K_L_M) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *A_B_C_D_E_F_G_H_I_J_K_L_M) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of A_B_C_D_E_F_G_H_I_J_K_L_M.
func (*A_B_C_D_E_F_G_H_I_J_K_L_M) ΛBelongingModule() string {
	return "openconfig-nested"
}

// Container represents the /openconfig-nested/container YANG schema element.
type Container struct {
	Enabled *bool `path:"enabled" module:"openconfig-nested"`
}

// IsYANGGoStruct ensures that Container implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Container) IsYANGGoStruct() {}

// GetEnabled retrieves the value of the leaf Enabled from the Container
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Enabled is set, it can
// safely use t.GetEnabled() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Enabled == nil' before retrieving the leaf's value.
func (t *Container) GetEnabled() bool {
	if t == nil || t.Enabled == nil {
		return false
	}
	return *t.Enabled
}

// SetEnabled sets the value of the leaf Enabled in the Container
// struct.
func (t *Container) SetEnabled(v bool) {
	t.Enabled = &v
}

// PopulateDefaults recursively populates unset leaf fields in the Container
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Container) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Container) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Container"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Container) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Container) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Container.
func (*Container) ΛBelongingModule() string {
	return "openconfig-nested"
}

// Model represents the /openconfig-withlistval/model YANG schema element.
type Model struct {
	MultiKey  map[Model_MultiKey_Key]*Model_MultiKey `path:"b/multi-key" module:"openconfig-withlistval/openconfig-withlistval"`
	NoKey     []*Model_NoKey                         `path:"c/no-key" module:"openconfig-withlistval/openconfig-withlistval"`
	SingleKey map[string]*Model_SingleKey            `path:"a/single-key" module:"openconfig-withlistval/openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model) IsYANGGoStruct() {}

// Model_MultiKey_Key represents the key for list MultiKey of element /openconfig-withlistval/model.
type Model_MultiKey_Key struct {
	Key1 uint32 `path:"key1"`
	Key2 uint64 `path:"key2"`
}

// IsYANGGoKeyStruct ensures that Model_MultiKey_Key partially implements the
// yang.GoKeyStruct interface. This allows functions that need to
// handle this key struct to identify it as being generated by gogen.
func (Model_MultiKey_Key) IsYANGGoKeyStruct() {}

// ΛListKeyMap returns the values of the Model_MultiKey_Key key struct.
func (t Model_MultiKey_Key) ΛListKeyMap() (map[string]interface{}, error) {
	return map[string]interface{}{
		"key1": t.Key1,
		"key2": t.Key2,
	}, nil
}

// NewMultiKey creates a new entry in the MultiKey list of the
// Model struct. The keys of the list are populated from the input
// arguments.
func (t *Model) NewMultiKey(Key1 uint32, Key2 uint64) (*Model_MultiKey, error) {

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.MultiKey == nil {
		t.MultiKey = make(map[Model_MultiKey_Key]*Model_MultiKey)
	}

	key := Model_MultiKey_Key{
		Key1: Key1,
		Key2: Key2,
	}

	// Ensure that this key has not already been used in the
	// list. Keyed YANG lists do not allow duplicate keys to
	// be created.
	if _, ok := t.MultiKey[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list MultiKey", key)
	}

	t.MultiKey[key] = &Model_MultiKey{
		Key1: &Key1,
		Key2: &Key2,
	}

	return t.MultiKey[key], nil
}

// RenameMultiKey renames an entry in the list MultiKey within
// the Model struct. The entry with key oldK is renamed to newK updating
// the key within the value.
func (t *Model) RenameMultiKey(oldK, newK Model_MultiKey_Key) error {
	if _, ok := t.MultiKey[newK]; ok {
		return fmt.Errorf("key %v already exists in MultiKey", newK)
	}

	e, ok := t.MultiKey[oldK]
	if !ok {
		return fmt.Errorf("key %v not found in MultiKey", oldK)
	}
	e.Key1 = &newK.Key1
	e.Key2 = &newK.Key2

	t.MultiKey[newK] = e
	delete(t.MultiKey, oldK)
	return nil
}

// GetOrCreateMultiKeyMap returns the list (map) from Model.
//
// It initializes the field if not already initialized.
func (t *Model) GetOrCreateMultiKeyMap() map[Model_MultiKey_Key]*Model_MultiKey {
	if t.MultiKey == nil {
		t.MultiKey = make(map[Model_MultiKey_Key]*Model_MultiKey)
	}
	return t.MultiKey
}

// GetOrCreateMultiKey retrieves the value with the specified keys from
// the receiver Model. If the entry does not exist, then it is created.
// It returns the existing or new list member.
func (t *Model) GetOrCreateMultiKey(Key1 uint32, Key2 uint64) *Model_MultiKey {

	key := Model_MultiKey_Key{
		Key1: Key1,
		Key2: Key2,
	}

	if v, ok := t.MultiKey[key]; ok {
		return v
	}
	// Panic if we receive an error, since we should have retrieved an existing
	// list member. This allows chaining of GetOrCreate methods.
	v, err := t.NewMultiKey(Key1, Key2)
	if err != nil {
		panic(fmt.Sprintf("GetOrCreateMultiKey got unexpected error: %v", err))
	}
	return v
}

// GetMultiKey retrieves the value with the specified key from
// the MultiKey map field of Model. If the receiver is nil, or
// the specified key is not present in the list, nil is returned such that Get*
// methods may be safely chained.
func (t *Model) GetMultiKey(Key1 uint32, Key2 uint64) *Model_MultiKey {

	if t == nil {
		return nil
	}

	key := Model_MultiKey_Key{
		Key1: Key1,
		Key2: Key2,
	}

	if lm, ok := t.MultiKey[key]; ok {
		return lm
	}
	return nil
}

// DeleteMultiKey deletes the value with the specified keys from
// the receiver Model. If there is no such element, the function
// is a no-op.
func (t *Model) DeleteMultiKey(Key1 uint32, Key2 uint64) {
	key := Model_MultiKey_Key{
		Key1: Key1,
		Key2: Key2,
	}

	delete(t.MultiKey, key)
}

// AppendMultiKey appends the supplied Model_MultiKey struct to the
// list MultiKey of Model. If the key value(s) specified in
// the supplied Model_MultiKey already exist in the list, an error is
// returned.
func (t *Model) AppendMultiKey(v *Model_MultiKey) error {
	if v.Key1 == nil {
		return fmt.Errorf("invalid nil key for Key1")
	}

	if v.Key2 == nil {
		return fmt.Errorf("invalid nil key for Key2")
	}

	key := Model_MultiKey_Key{
		Key1: *v.Key1,
		Key2: *v.Key2,
	}

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.MultiKey == nil {
		t.MultiKey = make(map[Model_MultiKey_Key]*Model_MultiKey)
	}

	if _, ok := t.MultiKey[key]; ok {
		return fmt.Errorf("duplicate key for list MultiKey %v", key)
	}

	t.MultiKey[key] = v
	return nil
}

// NewSingleKey creates a new entry in the SingleKey list of the
// Model struct. The keys of the list are populated from the input
// arguments.
func (t *Model) NewSingleKey(Key string) (*Model_SingleKey, error) {

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.SingleKey == nil {
		t.SingleKey = make(map[string]*Model_SingleKey)
	}

	key := Key

	// Ensure that this key has not already been used in the
	// list. Keyed YANG lists do not allow duplicate keys to
	// be created.
	if _, ok := t.SingleKey[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list SingleKey", key)
	}

	t.SingleKey[key] = &Model_SingleKey{
		Key: &Key,
	}

	return t.SingleKey[key], nil
}

// RenameSingleKey renames an entry in the list SingleKey within
// the Model struct. The entry with key oldK is renamed to newK updating
// the key within the value.
func (t *Model) RenameSingleKey(oldK, newK string) error {
	if _, ok := t.SingleKey[newK]; ok {
		return fmt.Errorf("key %v already exists in SingleKey", newK)
	}

	e, ok := t.SingleKey[oldK]
	if !ok {
		return fmt.Errorf("key %v not found in SingleKey", oldK)
	}
	e.Key = &newK

	t.SingleKey[newK] = e
	delete(t.SingleKey, oldK)
	return nil
}

// GetOrCreateSingleKeyMap returns the list (map) from Model.
//
// It initializes the field if not already initialized.
func (t *Model) GetOrCreateSingleKeyMap() map[string]*Model_SingleKey {
	if t.SingleKey == nil {
		t.SingleKey = make(map[string]*Model_SingleKey)
	}
	return t.SingleKey
}

// GetOrCreateSingleKey retrieves the value with the specified keys from
// the receiver Model. If the entry does not exist, then it is created.
// It returns the existing or new list member.
func (t *Model) GetOrCreateSingleKey(Key string) *Model_SingleKey {

	key := Key

	if v, ok := t.SingleKey[key]; ok {
		return v
	}
	// Panic if we receive an error, since we should have retrieved an existing
	// list member. This allows chaining of GetOrCreate methods.
	v, err := t.NewSingleKey(Key)
	if err != nil {
		panic(fmt.Sprintf("GetOrCreateSingleKey got unexpected error: %v", err))
	}
	return v
}

// GetSingleKey retrieves the value with the specified key from
// the SingleKey map field of Model. If the receiver is nil, or
// the specified key is not present in the list, nil is returned such that Get*
// methods may be safely chained.
func (t *Model) GetSingleKey(Key string) *Model_SingleKey {

	if t == nil {
		return nil
	}

	key := Key

	if lm, ok := t.SingleKey[key]; ok {
		return lm
	}
	return nil
}

// DeleteSingleKey deletes the value with the specified keys from
// the receiver Model. If there is no such element, the function
// is a no-op.
func (t *Model) DeleteSingleKey(Key string) {
	key := Key

	delete(t.SingleKey, key)
}

// AppendSingleKey appends the supplied Model_SingleKey struct to the
// list SingleKey of Model. If the key value(s) specified in
// the supplied Model_SingleKey already exist in the list, an error is
// returned.
func (t *Model) AppendSingleKey(v *Model_SingleKey) error {
	if v.Key == nil {
		return fmt.Errorf("invalid nil key received for Key")
	}

	key := *v.Key

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.SingleKey == nil {
		t.SingleKey = make(map[string]*Model_SingleKey)
	}

	if _, ok := t.SingleKey[key]; ok {
		return fmt.Errorf("duplicate key for list SingleKey %v", key)
	}

	t.SingleKey[key] = v
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the Model
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	for _, e := range t.MultiKey {
		e.PopulateDefaults()
	}
	for _, e := range t.NoKey {
		e.PopulateDefaults()
	}
	for _, e := range t.SingleKey {
		e.PopulateDefaults()
	}
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model.
func (*Model) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Model_MultiKey represents the /openconfig-withlistval/model/b/multi-key YANG schema element.
type Model_MultiKey struct {
	Key1 *uint32 `path:"config/key1|key1" module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval" shadow-path:"state/key1|key1" shadow-module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval"`
	Key2 *uint64 `path:"config/key2|key2" module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval" shadow-path:"state/key2|key2" shadow-module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model_MultiKey implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model_MultiKey) IsYANGGoStruct() {}

// GetKey1 retrieves the value of the leaf Key1 from the Model_MultiKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Key1 is set, it can
// safely use t.GetKey1() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Key1 == nil' before retrieving the leaf's value.
func (t *Model_MultiKey) GetKey1() uint32 {
	if t == nil || t.Key1 == nil {
		return 0
	}
	return *t.Key1
}

// GetKey2 retrieves the value of the leaf Key2 from the Model_MultiKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Key2 is set, it can
// safely use t.GetKey2() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Key2 == nil' before retrieving the leaf's value.
func (t *Model_MultiKey) GetKey2() uint64 {
	if t == nil || t.Key2 == nil {
		return 0
	}
	return *t.Key2
}

// SetKey1 sets the value of the leaf Key1 in the Model_MultiKey
// struct.
func (t *Model_MultiKey) SetKey1(v uint32) {
	t.Key1 = &v
}

// SetKey2 sets the value of the leaf Key2 in the Model_MultiKey
// struct.
func (t *Model_MultiKey) SetKey2(v uint64) {
	t.Key2 = &v
}

// PopulateDefaults recursively populates unset leaf fields in the Model_MultiKey
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model_MultiKey) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// ΛListKeyMap returns the keys of the Model_MultiKey struct, which is a YANG list entry.
func (t *Model_MultiKey) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Key1 == nil {
		return nil, fmt.Errorf("nil value for key Key1")
	}

	if t.Key2 == nil {
		return nil, fmt.Errorf("nil value for key Key2")
	}

	return map[string]interface{}{
		"key1": *t.Key1,
		"key2": *t.Key2,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_MultiKey) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model_MultiKey"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_MultiKey) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model_MultiKey) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model_MultiKey.
func (*Model_MultiKey) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Model_NoKey represents the /openconfig-withlistval/model/c/no-key YANG schema element.
type Model_NoKey struct {
	Foo *Model_NoKey_Foo `path:"foo" module:"openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model_NoKey implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model_NoKey) IsYANGGoStruct() {}

// GetOrCreateFoo retrieves the value of the Foo field
// or returns the existing field if it already exists.
func (t *Model_NoKey) GetOrCreateFoo() *Model_NoKey_Foo {
	if t.Foo != nil {
		return t.Foo
	}
	t.Foo = &Model_NoKey_Foo{}
	return t.Foo
}

// GetFoo returns the value of the Foo struct pointer
// from Model_NoKey. If the receiver or the field Foo is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Model_NoKey) GetFoo() *Model_NoKey_Foo {
	if t != nil && t.Foo != nil {
		return t.Foo
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the Model_NoKey
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model_NoKey) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.Foo.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_NoKey) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model_NoKey"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_NoKey) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model_NoKey) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model_NoKey.
func (*Model_NoKey) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Model_NoKey_Foo represents the /openconfig-withlistval/model/c/no-key/foo YANG schema element.
type Model_NoKey_Foo struct {
	Key   *string `path:"state/key" module:"openconfig-withlistval/openconfig-withlistval"`
	Value *int64  `path:"state/value" module:"openconfig-withlistval/openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model_NoKey_Foo implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model_NoKey_Foo) IsYANGGoStruct() {}

// GetKey retrieves the value of the leaf Key from the Model_NoKey_Foo
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Key is set, it can
// safely use t.GetKey() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Key == nil' before retrieving the leaf's value.
func (t *Model_NoKey_Foo) GetKey() string {
	if t == nil || t.Key == nil {
		return ""
	}
	return *t.Key
}

// GetValue retrieves the value of the leaf Value from the Model_NoKey_Foo
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Value is set, it can
// safely use t.GetValue() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Value == nil' before retrieving the leaf's value.
func (t *Model_NoKey_Foo) GetValue() int64 {
	if t == nil || t.Value == nil {
		return 0
	}
	return *t.Value
}

// SetKey sets the value of the leaf Key in the Model_NoKey_Foo
// struct.
func (t *Model_NoKey_Foo) SetKey(v string) {
	t.Key = &v
}

// SetValue sets the value of the leaf Value in the Model_NoKey_Foo
// struct.
func (t *Model_NoKey_Foo) SetValue(v int64) {
	t.Value = &v
}

// PopulateDefaults recursively populates unset leaf fields in the Model_NoKey_Foo
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model_NoKey_Foo) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_NoKey_Foo) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model_NoKey_Foo"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_NoKey_Foo) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model_NoKey_Foo) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model_NoKey_Foo.
func (*Model_NoKey_Foo) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Model_SingleKey represents the /openconfig-withlistval/model/a/single-key YANG schema element.
type Model_SingleKey struct {
	Counter     Binary                                  `path:"state/counter" module:"openconfig-withlistval/openconfig-withlistval"`
	Counters    []Binary                                `path:"state/counters" module:"openconfig-withlistval/openconfig-withlistval"`
	Key         *string                                 `path:"config/key|key" module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval" shadow-path:"state/key|key" shadow-module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval"`
	OrderedList *Model_SingleKey_OrderedList_OrderedMap `path:"ordered-lists/ordered-list" module:"openconfig-withlistval/openconfig-withlistval"`
	SingleKey   map[string]*Model_SingleKey_SingleKey   `path:"inner-a/single-key" module:"openconfig-withlistval/openconfig-withlistval"`
	Value       *int64                                  `path:"config/value" module:"openconfig-withlistval/openconfig-withlistval" shadow-path:"state/value" shadow-module:"openconfig-withlistval/openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model_SingleKey implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model_SingleKey) IsYANGGoStruct() {}

// NewSingleKey creates a new entry in the SingleKey list of the
// Model_SingleKey struct. The keys of the list are populated from the input
// arguments.
func (t *Model_SingleKey) NewSingleKey(Key string) (*Model_SingleKey_SingleKey, error) {

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.SingleKey == nil {
		t.SingleKey = make(map[string]*Model_SingleKey_SingleKey)
	}

	key := Key

	// Ensure that this key has not already been used in the
	// list. Keyed YANG lists do not allow duplicate keys to
	// be created.
	if _, ok := t.SingleKey[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list SingleKey", key)
	}

	t.SingleKey[key] = &Model_SingleKey_SingleKey{
		Key: &Key,
	}

	return t.SingleKey[key], nil
}

// RenameSingleKey renames an entry in the list SingleKey within
// the Model_SingleKey struct. The entry with key oldK is renamed to newK updating
// the key within the value.
func (t *Model_SingleKey) RenameSingleKey(oldK, newK string) error {
	if _, ok := t.SingleKey[newK]; ok {
		return fmt.Errorf("key %v already exists in SingleKey", newK)
	}

	e, ok := t.SingleKey[oldK]
	if !ok {
		return fmt.Errorf("key %v not found in SingleKey", oldK)
	}
	e.Key = &newK

	t.SingleKey[newK] = e
	delete(t.SingleKey, oldK)
	return nil
}

// GetOrCreateSingleKeyMap returns the list (map) from Model_SingleKey.
//
// It initializes the field if not already initialized.
func (t *Model_SingleKey) GetOrCreateSingleKeyMap() map[string]*Model_SingleKey_SingleKey {
	if t.SingleKey == nil {
		t.SingleKey = make(map[string]*Model_SingleKey_SingleKey)
	}
	return t.SingleKey
}

// GetOrCreateSingleKey retrieves the value with the specified keys from
// the receiver Model_SingleKey. If the entry does not exist, then it is created.
// It returns the existing or new list member.
func (t *Model_SingleKey) GetOrCreateSingleKey(Key string) *Model_SingleKey_SingleKey {

	key := Key

	if v, ok := t.SingleKey[key]; ok {
		return v
	}
	// Panic if we receive an error, since we should have retrieved an existing
	// list member. This allows chaining of GetOrCreate methods.
	v, err := t.NewSingleKey(Key)
	if err != nil {
		panic(fmt.Sprintf("GetOrCreateSingleKey got unexpected error: %v", err))
	}
	return v
}

// GetSingleKey retrieves the value with the specified key from
// the SingleKey map field of Model_SingleKey. If the receiver is nil, or
// the specified key is not present in the list, nil is returned such that Get*
// methods may be safely chained.
func (t *Model_SingleKey) GetSingleKey(Key string) *Model_SingleKey_SingleKey {

	if t == nil {
		return nil
	}

	key := Key

	if lm, ok := t.SingleKey[key]; ok {
		return lm
	}
	return nil
}

// DeleteSingleKey deletes the value with the specified keys from
// the receiver Model_SingleKey. If there is no such element, the function
// is a no-op.
func (t *Model_SingleKey) DeleteSingleKey(Key string) {
	key := Key

	delete(t.SingleKey, key)
}

// AppendSingleKey appends the supplied Model_SingleKey_SingleKey struct to the
// list SingleKey of Model_SingleKey. If the key value(s) specified in
// the supplied Model_SingleKey_SingleKey already exist in the list, an error is
// returned.
func (t *Model_SingleKey) AppendSingleKey(v *Model_SingleKey_SingleKey) error {
	if v.Key == nil {
		return fmt.Errorf("invalid nil key received for Key")
	}

	key := *v.Key

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.SingleKey == nil {
		t.SingleKey = make(map[string]*Model_SingleKey_SingleKey)
	}

	if _, ok := t.SingleKey[key]; ok {
		return fmt.Errorf("duplicate key for list SingleKey %v", key)
	}

	t.SingleKey[key] = v
	return nil
}

// GetCounter retrieves the value of the leaf Counter from the Model_SingleKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Counter is set, it can
// safely use t.GetCounter() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Counter == nil' before retrieving the leaf's value.
func (t *Model_SingleKey) GetCounter() Binary {
	if t == nil || t.Counter == nil {
		return nil
	}
	return t.Counter
}

// GetCounters retrieves the value of the leaf Counters from the Model_SingleKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Counters is set, it can
// safely use t.GetCounters() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Counters == nil' before retrieving the leaf's value.
func (t *Model_SingleKey) GetCounters() []Binary {
	if t == nil || t.Counters == nil {
		return nil
	}
	return t.Counters
}

// GetKey retrieves the value of the leaf Key from the Model_SingleKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Key is set, it can
// safely use t.GetKey() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Key == nil' before retrieving the leaf's value.
func (t *Model_SingleKey) GetKey() string {
	if t == nil || t.Key == nil {
		return ""
	}
	return *t.Key
}

// GetValue retrieves the value of the leaf Value from the Model_SingleKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Value is set, it can
// safely use t.GetValue() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Value == nil' before retrieving the leaf's value.
func (t *Model_SingleKey) GetValue() int64 {
	if t == nil || t.Value == nil {
		return 0
	}
	return *t.Value
}

// SetCounter sets the value of the leaf Counter in the Model_SingleKey
// struct.
func (t *Model_SingleKey) SetCounter(v Binary) {
	t.Counter = v
}

// SetCounters sets the value of the leaf Counters in the Model_SingleKey
// struct.
func (t *Model_SingleKey) SetCounters(v []Binary) {
	t.Counters = v
}

// SetKey sets the value of the leaf Key in the Model_SingleKey
// struct.
func (t *Model_SingleKey) SetKey(v string) {
	t.Key = &v
}

// SetValue sets the value of the leaf Value in the Model_SingleKey
// struct.
func (t *Model_SingleKey) SetValue(v int64) {
	t.Value = &v
}

// GetOrCreateOrderedListMap returns the ordered map field
// OrderedList from Model_SingleKey.
//
// It initializes the field if not already initialized.
func (s *Model_SingleKey) GetOrCreateOrderedListMap() *Model_SingleKey_OrderedList_OrderedMap {
	if s.OrderedList == nil {
		s.OrderedList = &Model_SingleKey_OrderedList_OrderedMap{}
	}
	return s.OrderedList
}

// AppendNewOrderedList creates a new entry in the OrderedList
// ordered map of the Model_SingleKey struct. The keys of the list are
// populated from the input arguments.
func (s *Model_SingleKey) AppendNewOrderedList(Key string) (*Model_SingleKey_OrderedList, error) {
	if s.OrderedList == nil {
		s.OrderedList = &Model_SingleKey_OrderedList_OrderedMap{}
	}
	return s.OrderedList.AppendNew(Key)
}

// AppendOrderedList appends the supplied Model_SingleKey_OrderedList struct
// to the list OrderedList of Model_SingleKey. If the key value(s)
// specified in the supplied Model_SingleKey_OrderedList already exist in the list, an
// error is returned.
func (s *Model_SingleKey) AppendOrderedList(v *Model_SingleKey_OrderedList) error {
	if s.OrderedList == nil {
		s.OrderedList = &Model_SingleKey_OrderedList_OrderedMap{}
	}
	return s.OrderedList.Append(v)
}

// GetOrderedList retrieves the value with the specified key from the
// OrderedList map field of Model_SingleKey. If the receiver
// is nil, or the specified key is not present in the list, nil is returned
// such that Get* methods may be safely chained.
func (s *Model_SingleKey) GetOrderedList(Key string) *Model_SingleKey_OrderedList {
	if s == nil {
		return nil
	}
	key := Key
	return s.OrderedList.Get(key)
}

// DeleteOrderedList deletes the value with the specified keys from
// the receiver Model_SingleKey. If there is no such element, the
// function is a no-op.
func (s *Model_SingleKey) DeleteOrderedList(Key string) bool {
	key := Key
	return s.OrderedList.Delete(key)
}

// Model_SingleKey_OrderedList_OrderedMap is an ordered map that represents the "ordered-by user"
// list elements at /openconfig-withlistval/model/a/single-key/ordered-lists/ordered-list.
type Model_SingleKey_OrderedList_OrderedMap struct {
	keys     []string
	valueMap map[string]*Model_SingleKey_OrderedList
}

// IsYANGOrderedList ensures that Model_SingleKey_OrderedList_OrderedMap implements the
// ygot.GoOrderedMap interface.
func (*Model_SingleKey_OrderedList_OrderedMap) IsYANGOrderedList() {}

// init initializes any uninitialized values.
func (o *Model_SingleKey_OrderedList_OrderedMap) init() {
	if o == nil {
		return
	}
	if o.valueMap == nil {
		o.valueMap = map[string]*Model_SingleKey_OrderedList{}
	}
}

// Keys returns a copy of the list's keys.
func (o *Model_SingleKey_OrderedList_OrderedMap) Keys() []string {
	if o == nil {
		return nil
	}
	return append([]string{}, o.keys...)
}

// Values returns the current set of the list's values in order.
func (o *Model_SingleKey_OrderedList_OrderedMap) Values() []*Model_SingleKey_OrderedList {
	if o == nil {
		return nil
	}
	var values []*Model_SingleKey_OrderedList
	for _, key := range o.keys {
		values = append(values, o.valueMap[key])
	}
	return values
}

// Len returns a size of Model_SingleKey_OrderedList_OrderedMap
func (o *Model_SingleKey_OrderedList_OrderedMap) Len() int {
	if o == nil {
		return 0
	}
	return len(o.keys)
}

// Get returns the value corresponding to the key. If the key is not found, nil
// is returned.
func (o *Model_SingleKey_OrderedList_OrderedMap) Get(key string) *Model_SingleKey_OrderedList {
	if o == nil {
		return nil
	}
	val, _ := o.valueMap[key]
	return val
}

// Delete deletes an element.
func (o *Model_SingleKey_OrderedList_OrderedMap) Delete(key string) bool {
	if o == nil {
		return false
	}
	if _, ok := o.valueMap[key]; !ok {
		return false
	}
	for i, k := range o.keys {
		if k == key {
			o.keys = append(o.keys[:i], o.keys[i+1:]...)
			delete(o.valueMap, key)
			return true
		}
	}
	return false
}

// Append appends a Model_SingleKey_OrderedList, returning an error if the key
// already exists in the ordered list or if the key is unspecified.
func (o *Model_SingleKey_OrderedList_OrderedMap) Append(v *Model_SingleKey_OrderedList) error {
	if o == nil {
		return fmt.Errorf("nil ordered map, cannot append Model_SingleKey_OrderedList")
	}
	if v == nil {
		return fmt.Errorf("nil Model_SingleKey_OrderedList")
	}
	if v.Key == nil {
		return fmt.Errorf("invalid nil key received for Key")
	}

	key := *v.Key

	if _, ok := o.valueMap[key]; ok {
		return fmt.Errorf("duplicate key for list Statement %v", key)
	}
	o.keys = append(o.keys, key)
	o.init()
	o.valueMap[key] = v
	return nil
}

// AppendNew creates and appends a new Model_SingleKey_OrderedList, returning the
// newly-initialized v. It returns an error if the v already exists.
func (o *Model_SingleKey_OrderedList_OrderedMap) AppendNew(Key string) (*Model_SingleKey_OrderedList, error) {
	if o == nil {
		return nil, fmt.Errorf("nil ordered map, cannot append Model_SingleKey_OrderedList")
	}
	key := Key

	if _, ok := o.valueMap[key]; ok {
		return nil, fmt.Errorf("duplicate key for list Statement %v", key)
	}
	o.keys = append(o.keys, key)
	newElement := &Model_SingleKey_OrderedList{
		Key: &Key,
	}
	o.init()
	o.valueMap[key] = newElement
	return newElement, nil
}

// PopulateDefaults recursively populates unset leaf fields in the Model_SingleKey
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model_SingleKey) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	for _, e := range t.SingleKey {
		e.PopulateDefaults()
	}
	for _, e := range t.OrderedList.Values() {
		e.PopulateDefaults()
	}
}

// ΛListKeyMap returns the keys of the Model_SingleKey struct, which is a YANG list entry.
func (t *Model_SingleKey) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Key == nil {
		return nil, fmt.Errorf("nil value for key Key")
	}

	return map[string]interface{}{
		"key": *t.Key,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_SingleKey) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model_SingleKey"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_SingleKey) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model_SingleKey) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model_SingleKey.
func (*Model_SingleKey) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Model_SingleKey_OrderedList represents the /openconfig-withlistval/model/a/single-key/ordered-lists/ordered-list YANG schema element.
type Model_SingleKey_OrderedList struct {
	Key   *string `path:"config/key|key" module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval" shadow-path:"state/key|key" shadow-module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval"`
	Value *int64  `path:"config/value" module:"openconfig-withlistval/openconfig-withlistval" shadow-path:"state/value" shadow-module:"openconfig-withlistval/openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model_SingleKey_OrderedList implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model_SingleKey_OrderedList) IsYANGGoStruct() {}

// GetKey retrieves the value of the leaf Key from the Model_SingleKey_OrderedList
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Key is set, it can
// safely use t.GetKey() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Key == nil' before retrieving the leaf's value.
func (t *Model_SingleKey_OrderedList) GetKey() string {
	if t == nil || t.Key == nil {
		return ""
	}
	return *t.Key
}

// GetValue retrieves the value of the leaf Value from the Model_SingleKey_OrderedList
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Value is set, it can
// safely use t.GetValue() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Value == nil' before retrieving the leaf's value.
func (t *Model_SingleKey_OrderedList) GetValue() int64 {
	if t == nil || t.Value == nil {
		return 0
	}
	return *t.Value
}

// SetKey sets the value of the leaf Key in the Model_SingleKey_OrderedList
// struct.
func (t *Model_SingleKey_OrderedList) SetKey(v string) {
	t.Key = &v
}

// SetValue sets the value of the leaf Value in the Model_SingleKey_OrderedList
// struct.
func (t *Model_SingleKey_OrderedList) SetValue(v int64) {
	t.Value = &v
}

// PopulateDefaults recursively populates unset leaf fields in the Model_SingleKey_OrderedList
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model_SingleKey_OrderedList) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// ΛListKeyMap returns the keys of the Model_SingleKey_OrderedList struct, which is a YANG list entry.
func (t *Model_SingleKey_OrderedList) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Key == nil {
		return nil, fmt.Errorf("nil value for key Key")
	}

	return map[string]interface{}{
		"key": *t.Key,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_SingleKey_OrderedList) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model_SingleKey_OrderedList"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_SingleKey_OrderedList) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model_SingleKey_OrderedList) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model_SingleKey_OrderedList.
func (*Model_SingleKey_OrderedList) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Model_SingleKey_SingleKey represents the /openconfig-withlistval/model/a/single-key/inner-a/single-key YANG schema element.
type Model_SingleKey_SingleKey struct {
	Key   *string `path:"config/key|key" module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval" shadow-path:"state/key|key" shadow-module:"openconfig-withlistval/openconfig-withlistval|openconfig-withlistval"`
	Value *int64  `path:"config/value" module:"openconfig-withlistval/openconfig-withlistval" shadow-path:"state/value" shadow-module:"openconfig-withlistval/openconfig-withlistval"`
}

// IsYANGGoStruct ensures that Model_SingleKey_SingleKey implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Model_SingleKey_SingleKey) IsYANGGoStruct() {}

// GetKey retrieves the value of the leaf Key from the Model_SingleKey_SingleKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Key is set, it can
// safely use t.GetKey() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Key == nil' before retrieving the leaf's value.
func (t *Model_SingleKey_SingleKey) GetKey() string {
	if t == nil || t.Key == nil {
		return ""
	}
	return *t.Key
}

// GetValue retrieves the value of the leaf Value from the Model_SingleKey_SingleKey
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Value is set, it can
// safely use t.GetValue() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Value == nil' before retrieving the leaf's value.
func (t *Model_SingleKey_SingleKey) GetValue() int64 {
	if t == nil || t.Value == nil {
		return 0
	}
	return *t.Value
}

// SetKey sets the value of the leaf Key in the Model_SingleKey_SingleKey
// struct.
func (t *Model_SingleKey_SingleKey) SetKey(v string) {
	t.Key = &v
}

// SetValue sets the value of the leaf Value in the Model_SingleKey_SingleKey
// struct.
func (t *Model_SingleKey_SingleKey) SetValue(v int64) {
	t.Value = &v
}

// PopulateDefaults recursively populates unset leaf fields in the Model_SingleKey_SingleKey
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Model_SingleKey_SingleKey) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// ΛListKeyMap returns the keys of the Model_SingleKey_SingleKey struct, which is a YANG list entry.
func (t *Model_SingleKey_SingleKey) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Key == nil {
		return nil, fmt.Errorf("nil value for key Key")
	}

	return map[string]interface{}{
		"key": *t.Key,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_SingleKey_SingleKey) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Model_SingleKey_SingleKey"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Model_SingleKey_SingleKey) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Model_SingleKey_SingleKey) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Model_SingleKey_SingleKey.
func (*Model_SingleKey_SingleKey) ΛBelongingModule() string {
	return "openconfig-withlistval"
}

// Parent represents the /openconfig-simple/parent YANG schema element.
type Parent struct {
	Child *Parent_Child `path:"child" module:"openconfig-simple"`
}

// IsYANGGoStruct ensures that Parent implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Parent) IsYANGGoStruct() {}

// GetOrCreateChild retrieves the value of the Child field
// or returns the existing field if it already exists.
func (t *Parent) GetOrCreateChild() *Parent_Child {
	if t.Child != nil {
		return t.Child
	}
	t.Child = &Parent_Child{}
	return t.Child
}

// GetChild returns the value of the Child struct pointer
// from Parent. If the receiver or the field Child is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Parent) GetChild() *Parent_Child {
	if t != nil && t.Child != nil {
		return t.Child
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the Parent
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Parent) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.Child.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Parent) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Parent"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Parent) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Parent) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Parent.
func (*Parent) ΛBelongingModule() string {
	return "openconfig-simple"
}

// Parent_Child represents the /openconfig-simple/parent/child YANG schema element.
type Parent_Child struct {
	Five  Binary        `path:"config/five" module:"openconfig-simple/openconfig-simple" shadow-path:"state/five" shadow-module:"openconfig-simple/openconfig-simple"`
	Four  Binary        `path:"config/four" module:"openconfig-simple/openconfig-simple" shadow-path:"state/four" shadow-module:"openconfig-simple/openconfig-simple"`
	One   *string       `path:"config/one" module:"openconfig-simple/openconfig-simple" shadow-path:"state/one" shadow-module:"openconfig-simple/openconfig-simple"`
	Six   []Binary      `path:"config/six" module:"openconfig-simple/openconfig-simple" shadow-path:"state/six" shadow-module:"openconfig-simple/openconfig-simple"`
	Three E_Child_Three `path:"config/three" module:"openconfig-simple/openconfig-simple" shadow-path:"state/three" shadow-module:"openconfig-simple/openconfig-simple"`
	Two   *string       `path:"state/two" module:"openconfig-simple/openconfig-simple"`
}

// IsYANGGoStruct ensures that Parent_Child implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Parent_Child) IsYANGGoStruct() {}

// GetFive retrieves the value of the leaf Five from the Parent_Child
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Five is set, it can
// safely use t.GetFive() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Five == nil' before retrieving the leaf's value.
func (t *Parent_Child) GetFive() Binary {
	if t == nil || t.Five == nil {
		return nil
	}
	return t.Five
}

// GetFour retrieves the value of the leaf Four from the Parent_Child
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Four is set, it can
// safely use t.GetFour() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Four == nil' before retrieving the leaf's value.
func (t *Parent_Child) GetFour() Binary {
	if t == nil || t.Four == nil {
		return nil
	}
	return t.Four
}

// GetOne retrieves the value of the leaf One from the Parent_Child
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if One is set, it can
// safely use t.GetOne() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.One == nil' before retrieving the leaf's value.
func (t *Parent_Child) GetOne() string {
	if t == nil || t.One == nil {
		return ""
	}
	return *t.One
}

// GetSix retrieves the value of the leaf Six from the Parent_Child
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Six is set, it can
// safely use t.GetSix() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Six == nil' before retrieving the leaf's value.
func (t *Parent_Child) GetSix() []Binary {
	if t == nil || t.Six == nil {
		return nil
	}
	return t.Six
}

// GetThree retrieves the value of the leaf Three from the Parent_Child
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Three is set, it can
// safely use t.GetThree() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Three == nil' before retrieving the leaf's value.
func (t *Parent_Child) GetThree() E_Child_Three {
	if t == nil || t.Three == 0 {
		return 0
	}
	return t.Three
}

// GetTwo retrieves the value of the leaf Two from the Parent_Child
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if Two is set, it can
// safely use t.GetTwo() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.Two == nil' before retrieving the leaf's value.
func (t *Parent_Child) GetTwo() string {
	if t == nil || t.Two == nil {
		return ""
	}
	return *t.Two
}

// SetFive sets the value of the leaf Five in the Parent_Child
// struct.
func (t *Parent_Child) SetFive(v Binary) {
	t.Five = v
}

// SetFour sets the value of the leaf Four in the Parent_Child
// struct.
func (t *Parent_Child) SetFour(v Binary) {
	t.Four = v
}

// SetOne sets the value of the leaf One in the Parent_Child
// struct.
func (t *Parent_Child) SetOne(v string) {
	t.One = &v
}

// SetSix sets the value of the leaf Six in the Parent_Child
// struct.
func (t *Parent_Child) SetSix(v []Binary) {
	t.Six = v
}

// SetThree sets the value of the leaf Three in the Parent_Child
// struct.
func (t *Parent_Child) SetThree(v E_Child_Three) {
	t.Three = v
}

// SetTwo sets the value of the leaf Two in the Parent_Child
// struct.
func (t *Parent_Child) SetTwo(v string) {
	t.Two = &v
}

// PopulateDefaults recursively populates unset leaf fields in the Parent_Child
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Parent_Child) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Parent_Child) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Parent_Child"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Parent_Child) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Parent_Child) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Parent_Child.
func (*Parent_Child) ΛBelongingModule() string {
	return "openconfig-simple"
}

// RemoteContainer represents the /openconfig-simple/remote-container YANG schema element.
type RemoteContainer struct {
	ALeaf *string `path:"config/a-leaf" module:"openconfig-simple/openconfig-simple" shadow-path:"state/a-leaf" shadow-module:"openconfig-simple/openconfig-simple"`
}

// IsYANGGoStruct ensures that RemoteContainer implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*RemoteContainer) IsYANGGoStruct() {}

// GetALeaf retrieves the value of the leaf ALeaf from the RemoteContainer
// struct. If the field is unset but has a default value in the YANG schema,
// then the default value will be returned.
// Caution should be exercised whilst using this method since when without a
// default value, it will return the Go zero value if the field is explicitly
// unset. If the caller explicitly does not care if ALeaf is set, it can
// safely use t.GetALeaf() to retrieve the value. In the case that the
// caller has different actions based on whether the leaf is set or unset, it
// should use 'if t.ALeaf == nil' before retrieving the leaf's value.
func (t *RemoteContainer) GetALeaf() string {
	if t == nil || t.ALeaf == nil {
		return ""
	}
	return *t.ALeaf
}

// SetALeaf sets the value of the leaf ALeaf in the RemoteContainer
// struct.
func (t *RemoteContainer) SetALeaf(v string) {
	t.ALeaf = &v
}

// PopulateDefaults recursively populates unset leaf fields in the RemoteContainer
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *RemoteContainer) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *RemoteContainer) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["RemoteContainer"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *RemoteContainer) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *RemoteContainer) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of RemoteContainer.
func (*RemoteContainer) ΛBelongingModule() string {
	return "openconfig-simple"
}

// Root represents the /root YANG schema element.
type Root struct {
	A               *A               `path:"a" module:"openconfig-nested"`
	Container       *Container       `path:"container" module:"openconfig-nested"`
	Model           *Model           `path:"model" module:"openconfig-withlistval"`
	Parent          *Parent          `path:"parent" module:"openconfig-simple"`
	RemoteContainer *RemoteContainer `path:"remote-container" module:"openconfig-simple"`
}

// IsYANGGoStruct ensures that Root implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Root) IsYANGGoStruct() {}

// GetOrCreateA retrieves the value of the A field
// or returns the existing field if it already exists.
func (t *Root) GetOrCreateA() *A {
	if t.A != nil {
		return t.A
	}
	t.A = &A{}
	return t.A
}

// GetOrCreateContainer retrieves the value of the Container field
// or returns the existing field if it already exists.
func (t *Root) GetOrCreateContainer() *Container {
	if t.Container != nil {
		return t.Container
	}
	t.Container = &Container{}
	return t.Container
}

// GetOrCreateModel retrieves the value of the Model field
// or returns the existing field if it already exists.
func (t *Root) GetOrCreateModel() *Model {
	if t.Model != nil {
		return t.Model
	}
	t.Model = &Model{}
	return t.Model
}

// GetOrCreateParent retrieves the value of the Parent field
// or returns the existing field if it already exists.
func (t *Root) GetOrCreateParent() *Parent {
	if t.Parent != nil {
		return t.Parent
	}
	t.Parent = &Parent{}
	return t.Parent
}

// GetOrCreateRemoteContainer retrieves the value of the RemoteContainer field
// or returns the existing field if it already exists.
func (t *Root) GetOrCreateRemoteContainer() *RemoteContainer {
	if t.RemoteContainer != nil {
		return t.RemoteContainer
	}
	t.RemoteContainer = &RemoteContainer{}
	return t.RemoteContainer
}

// GetA returns the value of the A struct pointer
// from Root. If the receiver or the field A is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Root) GetA() *A {
	if t != nil && t.A != nil {
		return t.A
	}
	return nil
}

// GetContainer returns the value of the Container struct pointer
// from Root. If the receiver or the field Container is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Root) GetContainer() *Container {
	if t != nil && t.Container != nil {
		return t.Container
	}
	return nil
}

// GetModel returns the value of the Model struct pointer
// from Root. If the receiver or the field Model is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Root) GetModel() *Model {
	if t != nil && t.Model != nil {
		return t.Model
	}
	return nil
}

// GetParent returns the value of the Parent struct pointer
// from Root. If the receiver or the field Parent is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Root) GetParent() *Parent {
	if t != nil && t.Parent != nil {
		return t.Parent
	}
	return nil
}

// GetRemoteContainer returns the value of the RemoteContainer struct pointer
// from Root. If the receiver or the field RemoteContainer is nil, nil
// is returned such that the Get* methods can be safely chained.
func (t *Root) GetRemoteContainer() *RemoteContainer {
	if t != nil && t.RemoteContainer != nil {
		return t.RemoteContainer
	}
	return nil
}

// PopulateDefaults recursively populates unset leaf fields in the Root
// with default values as specified in the YANG schema, instantiating any nil
// container fields.
func (t *Root) PopulateDefaults() {
	if t == nil {
		return
	}
	ygot.BuildEmptyTree(t)
	t.A.PopulateDefaults()
	t.Container.PopulateDefaults()
	t.Model.PopulateDefaults()
	t.Parent.PopulateDefaults()
	t.RemoteContainer.PopulateDefaults()
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Root) ΛValidate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Root"], t, opts...); err != nil {
		return err
	}
	return nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Root) Validate(opts ...ygot.ValidationOption) error {
	return t.ΛValidate(opts...)
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Root) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// ΛBelongingModule returns the name of the module that defines the namespace
// of Root.
func (*Root) ΛBelongingModule() string {
	return ""
}