generated.go

// Copyright 2022-2023 ETSI TeraFlowSDN - TFS OSG (https://tfs.etsi.org/)
//
// 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 gostruct 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 false
in this case).

This package was generated by /usr/share/gocode/src/github.com/openconfig/ygot/ygen/commongen.go
using the following YANG input files:
	- /root/public/release/models/optical-transport/openconfig-terminal-device.yang
	- /root/public/release/models/types/openconfig-types.yang
	- /root/public/release/models/openconfig-extensions.yang
	- /root/public/release/models/platform/openconfig-platform-types.yang
	- /root/public/release/models/system/openconfig-alarm-types.yang
	- /root/public/release/models/lldp/openconfig-lldp.yang
	- /root/public/release/models/interfaces/openconfig-interfaces.yang
Imported modules were sourced from:
*/
package gostruct

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

	"github.com/openconfig/ygot/ygot"
	"github.com/openconfig/goyang/pkg/yang"
	"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

var (
	SchemaTree map[string]*yang.Entry
)

func init() {
	var err error
	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: &Device{},
		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...)
}

// Device represents the /device YANG schema element.
type Device struct {
	Components	*OpenconfigPlatform_Components	`path:"components" module:"openconfig-platform"`
	Interfaces	*OpenconfigInterfaces_Interfaces	`path:"interfaces" module:"openconfig-interfaces"`
	InterfacesState	*IETFInterfaces_InterfacesState	`path:"interfaces-state" module:"ietf-interfaces"`
	Lldp	*OpenconfigLldp_Lldp	`path:"lldp" module:"openconfig-lldp"`
	TerminalDevice	*OpenconfigTerminalDevice_TerminalDevice	`path:"terminal-device" module:"openconfig-terminal-device"`
}

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

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

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


// IETFInterfaces_InterfacesState represents the /ietf-interfaces/interfaces-state YANG schema element.
type IETFInterfaces_InterfacesState struct {
	Interface	map[string]*IETFInterfaces_InterfacesState_Interface	`path:"interface" module:"ietf-interfaces"`
}

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

// NewInterface creates a new entry in the Interface list of the
// IETFInterfaces_InterfacesState struct. The keys of the list are populated from the input
// arguments.
func (t *IETFInterfaces_InterfacesState) NewInterface(Name string) (*IETFInterfaces_InterfacesState_Interface, error){

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

	key := Name

	// 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.Interface[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Interface", key)
	}

	t.Interface[key] = &IETFInterfaces_InterfacesState_Interface{
		Name: &Name,
	}

	return t.Interface[key], nil
}

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

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


// IETFInterfaces_InterfacesState_Interface represents the /ietf-interfaces/interfaces-state/interface YANG schema element.
type IETFInterfaces_InterfacesState_Interface struct {
	AdminStatus	E_IETFInterfaces_InterfacesState_Interface_AdminStatus	`path:"admin-status" module:"ietf-interfaces"`
	HigherLayerIf	[]string	`path:"higher-layer-if" module:"ietf-interfaces"`
	IfIndex	*int32	`path:"if-index" module:"ietf-interfaces"`
	LastChange	*string	`path:"last-change" module:"ietf-interfaces"`
	LowerLayerIf	[]string	`path:"lower-layer-if" module:"ietf-interfaces"`
	Name	*string	`path:"name" module:"ietf-interfaces"`
	OperStatus	E_IETFInterfaces_InterfacesState_Interface_OperStatus	`path:"oper-status" module:"ietf-interfaces"`
	PhysAddress	*string	`path:"phys-address" module:"ietf-interfaces"`
	Speed	*uint64	`path:"speed" module:"ietf-interfaces"`
	Statistics	*IETFInterfaces_InterfacesState_Interface_Statistics	`path:"statistics" module:"ietf-interfaces"`
	Type	E_IETFInterfaces_InterfaceType	`path:"type" module:"ietf-interfaces"`
}

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

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

	return map[string]interface{}{
		"name": *t.Name,
	}, nil
}

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

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


// IETFInterfaces_InterfacesState_Interface_Statistics represents the /ietf-interfaces/interfaces-state/interface/statistics YANG schema element.
type IETFInterfaces_InterfacesState_Interface_Statistics struct {
	DiscontinuityTime	*string	`path:"discontinuity-time" module:"ietf-interfaces"`
	InBroadcastPkts	*uint64	`path:"in-broadcast-pkts" module:"ietf-interfaces"`
	InDiscards	*uint32	`path:"in-discards" module:"ietf-interfaces"`
	InErrors	*uint32	`path:"in-errors" module:"ietf-interfaces"`
	InMulticastPkts	*uint64	`path:"in-multicast-pkts" module:"ietf-interfaces"`
	InOctets	*uint64	`path:"in-octets" module:"ietf-interfaces"`
	InUnicastPkts	*uint64	`path:"in-unicast-pkts" module:"ietf-interfaces"`
	InUnknownProtos	*uint32	`path:"in-unknown-protos" module:"ietf-interfaces"`
	OutBroadcastPkts	*uint64	`path:"out-broadcast-pkts" module:"ietf-interfaces"`
	OutDiscards	*uint32	`path:"out-discards" module:"ietf-interfaces"`
	OutErrors	*uint32	`path:"out-errors" module:"ietf-interfaces"`
	OutMulticastPkts	*uint64	`path:"out-multicast-pkts" module:"ietf-interfaces"`
	OutOctets	*uint64	`path:"out-octets" module:"ietf-interfaces"`
	OutUnicastPkts	*uint64	`path:"out-unicast-pkts" module:"ietf-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces represents the /openconfig-interfaces/interfaces YANG schema element.
type OpenconfigInterfaces_Interfaces struct {
	Interface	map[string]*OpenconfigInterfaces_Interfaces_Interface	`path:"interface" module:"openconfig-interfaces"`
}

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

// NewInterface creates a new entry in the Interface list of the
// OpenconfigInterfaces_Interfaces struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigInterfaces_Interfaces) NewInterface(Name string) (*OpenconfigInterfaces_Interfaces_Interface, error){

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

	key := Name

	// 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.Interface[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Interface", key)
	}

	t.Interface[key] = &OpenconfigInterfaces_Interfaces_Interface{
		Name: &Name,
	}

	return t.Interface[key], nil
}

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

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


// OpenconfigInterfaces_Interfaces_Interface represents the /openconfig-interfaces/interfaces/interface YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface struct {
	Config	*OpenconfigInterfaces_Interfaces_Interface_Config	`path:"config" module:"openconfig-interfaces"`
	Ethernet	*OpenconfigInterfaces_Interfaces_Interface_Ethernet	`path:"ethernet" module:"openconfig-if-ethernet"`
	HoldTime	*OpenconfigInterfaces_Interfaces_Interface_HoldTime	`path:"hold-time" module:"openconfig-interfaces"`
	Name	*string	`path:"name" module:"openconfig-interfaces"`
	State	*OpenconfigInterfaces_Interfaces_Interface_State	`path:"state" module:"openconfig-interfaces"`
	Subinterfaces	*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces	`path:"subinterfaces" module:"openconfig-interfaces"`
}

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

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

	return map[string]interface{}{
		"name": *t.Name,
	}, nil
}

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

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


// OpenconfigInterfaces_Interfaces_Interface_Config represents the /openconfig-interfaces/interfaces/interface/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Config struct {
	Description	*string	`path:"description" module:"openconfig-interfaces"`
	Enabled	*bool	`path:"enabled" module:"openconfig-interfaces"`
	LoopbackMode	*bool	`path:"loopback-mode" module:"openconfig-interfaces"`
	Mtu	*uint16	`path:"mtu" module:"openconfig-interfaces"`
	Name	*string	`path:"name" module:"openconfig-interfaces"`
	Type	E_IETFInterfaces_InterfaceType	`path:"type" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Ethernet represents the /openconfig-interfaces/interfaces/interface/ethernet YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Ethernet struct {
	Config	*OpenconfigInterfaces_Interfaces_Interface_Ethernet_Config	`path:"config" module:"openconfig-if-ethernet"`
	State	*OpenconfigInterfaces_Interfaces_Interface_Ethernet_State	`path:"state" module:"openconfig-if-ethernet"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Ethernet_Config represents the /openconfig-interfaces/interfaces/interface/ethernet/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Ethernet_Config struct {
	AutoNegotiate	*bool	`path:"auto-negotiate" module:"openconfig-if-ethernet"`
	DuplexMode	E_OpenconfigInterfaces_Interfaces_Interface_Ethernet_Config_DuplexMode	`path:"duplex-mode" module:"openconfig-if-ethernet"`
	EnableFlowControl	*bool	`path:"enable-flow-control" module:"openconfig-if-ethernet"`
	MacAddress	*string	`path:"mac-address" module:"openconfig-if-ethernet"`
	PortSpeed	E_OpenconfigIfEthernet_ETHERNET_SPEED	`path:"port-speed" module:"openconfig-if-ethernet"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Ethernet_State represents the /openconfig-interfaces/interfaces/interface/ethernet/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Ethernet_State struct {
	AutoNegotiate	*bool	`path:"auto-negotiate" module:"openconfig-if-ethernet"`
	Counters	*OpenconfigInterfaces_Interfaces_Interface_Ethernet_State_Counters	`path:"counters" module:"openconfig-if-ethernet"`
	DuplexMode	E_OpenconfigInterfaces_Interfaces_Interface_Ethernet_Config_DuplexMode	`path:"duplex-mode" module:"openconfig-if-ethernet"`
	EnableFlowControl	*bool	`path:"enable-flow-control" module:"openconfig-if-ethernet"`
	HwMacAddress	*string	`path:"hw-mac-address" module:"openconfig-if-ethernet"`
	MacAddress	*string	`path:"mac-address" module:"openconfig-if-ethernet"`
	NegotiatedDuplexMode	E_OpenconfigInterfaces_Interfaces_Interface_Ethernet_State_NegotiatedDuplexMode	`path:"negotiated-duplex-mode" module:"openconfig-if-ethernet"`
	NegotiatedPortSpeed	E_OpenconfigIfEthernet_ETHERNET_SPEED	`path:"negotiated-port-speed" module:"openconfig-if-ethernet"`
	PortSpeed	E_OpenconfigIfEthernet_ETHERNET_SPEED	`path:"port-speed" module:"openconfig-if-ethernet"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Ethernet_State_Counters represents the /openconfig-interfaces/interfaces/interface/ethernet/state/counters YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Ethernet_State_Counters struct {
	In_8021QFrames	*uint64	`path:"in-8021q-frames" module:"openconfig-if-ethernet"`
	InBlockErrors	*uint64	`path:"in-block-errors" module:"openconfig-if-ethernet"`
	InCrcErrors	*uint64	`path:"in-crc-errors" module:"openconfig-if-ethernet"`
	InFragmentFrames	*uint64	`path:"in-fragment-frames" module:"openconfig-if-ethernet"`
	InJabberFrames	*uint64	`path:"in-jabber-frames" module:"openconfig-if-ethernet"`
	InMacControlFrames	*uint64	`path:"in-mac-control-frames" module:"openconfig-if-ethernet"`
	InMacPauseFrames	*uint64	`path:"in-mac-pause-frames" module:"openconfig-if-ethernet"`
	InOversizeFrames	*uint64	`path:"in-oversize-frames" module:"openconfig-if-ethernet"`
	InUndersizeFrames	*uint64	`path:"in-undersize-frames" module:"openconfig-if-ethernet"`
	Out_8021QFrames	*uint64	`path:"out-8021q-frames" module:"openconfig-if-ethernet"`
	OutMacControlFrames	*uint64	`path:"out-mac-control-frames" module:"openconfig-if-ethernet"`
	OutMacPauseFrames	*uint64	`path:"out-mac-pause-frames" module:"openconfig-if-ethernet"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_HoldTime represents the /openconfig-interfaces/interfaces/interface/hold-time YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_HoldTime struct {
	Config	*OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config	`path:"config" module:"openconfig-interfaces"`
	State	*OpenconfigInterfaces_Interfaces_Interface_HoldTime_State	`path:"state" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config represents the /openconfig-interfaces/interfaces/interface/hold-time/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config struct {
	Down	*uint32	`path:"down" module:"openconfig-interfaces"`
	Up	*uint32	`path:"up" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_HoldTime_State represents the /openconfig-interfaces/interfaces/interface/hold-time/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_HoldTime_State struct {
	Down	*uint32	`path:"down" module:"openconfig-interfaces"`
	Up	*uint32	`path:"up" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_State represents the /openconfig-interfaces/interfaces/interface/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_State struct {
	AdminStatus	E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus	`path:"admin-status" module:"openconfig-interfaces"`
	Counters	*OpenconfigInterfaces_Interfaces_Interface_State_Counters	`path:"counters" module:"openconfig-interfaces"`
	Description	*string	`path:"description" module:"openconfig-interfaces"`
	Enabled	*bool	`path:"enabled" module:"openconfig-interfaces"`
	HardwarePort	*string	`path:"hardware-port" module:"openconfig-platform-port"`
	Ifindex	*uint32	`path:"ifindex" module:"openconfig-interfaces"`
	LastChange	*uint64	`path:"last-change" module:"openconfig-interfaces"`
	Logical	*bool	`path:"logical" module:"openconfig-interfaces"`
	LoopbackMode	*bool	`path:"loopback-mode" module:"openconfig-interfaces"`
	Mtu	*uint16	`path:"mtu" module:"openconfig-interfaces"`
	Name	*string	`path:"name" module:"openconfig-interfaces"`
	OperStatus	E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus	`path:"oper-status" module:"openconfig-interfaces"`
	PhysicalChannel	[]uint16	`path:"physical-channel" module:"openconfig-platform-transceiver"`
	Transceiver	*string	`path:"transceiver" module:"openconfig-platform-transceiver"`
	Type	E_IETFInterfaces_InterfaceType	`path:"type" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_State_Counters represents the /openconfig-interfaces/interfaces/interface/state/counters YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_State_Counters struct {
	CarrierTransitions	*uint64	`path:"carrier-transitions" module:"openconfig-interfaces"`
	InBroadcastPkts	*uint64	`path:"in-broadcast-pkts" module:"openconfig-interfaces"`
	InDiscards	*uint64	`path:"in-discards" module:"openconfig-interfaces"`
	InErrors	*uint64	`path:"in-errors" module:"openconfig-interfaces"`
	InFcsErrors	*uint64	`path:"in-fcs-errors" module:"openconfig-interfaces"`
	InMulticastPkts	*uint64	`path:"in-multicast-pkts" module:"openconfig-interfaces"`
	InOctets	*uint64	`path:"in-octets" module:"openconfig-interfaces"`
	InPkts	*uint64	`path:"in-pkts" module:"openconfig-interfaces"`
	InUnicastPkts	*uint64	`path:"in-unicast-pkts" module:"openconfig-interfaces"`
	InUnknownProtos	*uint64	`path:"in-unknown-protos" module:"openconfig-interfaces"`
	LastClear	*uint64	`path:"last-clear" module:"openconfig-interfaces"`
	OutBroadcastPkts	*uint64	`path:"out-broadcast-pkts" module:"openconfig-interfaces"`
	OutDiscards	*uint64	`path:"out-discards" module:"openconfig-interfaces"`
	OutErrors	*uint64	`path:"out-errors" module:"openconfig-interfaces"`
	OutMulticastPkts	*uint64	`path:"out-multicast-pkts" module:"openconfig-interfaces"`
	OutOctets	*uint64	`path:"out-octets" module:"openconfig-interfaces"`
	OutPkts	*uint64	`path:"out-pkts" module:"openconfig-interfaces"`
	OutUnicastPkts	*uint64	`path:"out-unicast-pkts" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces represents the /openconfig-interfaces/interfaces/interface/subinterfaces YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces struct {
	Subinterface	map[uint32]*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface	`path:"subinterface" module:"openconfig-interfaces"`
}

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

// NewSubinterface creates a new entry in the Subinterface list of the
// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces) NewSubinterface(Index uint32) (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface, error){

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

	key := Index

	// 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.Subinterface[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Subinterface", key)
	}

	t.Subinterface[key] = &OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface{
		Index: &Index,
	}

	return t.Subinterface[key], nil
}

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

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


// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface struct {
	Config	*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config	`path:"config" module:"openconfig-interfaces"`
	Index	*uint32	`path:"index" module:"openconfig-interfaces"`
	State	*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State	`path:"state" module:"openconfig-interfaces"`
}

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

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

	return map[string]interface{}{
		"index": *t.Index,
	}, nil
}

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

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


// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config struct {
	Description	*string	`path:"description" module:"openconfig-interfaces"`
	Enabled	*bool	`path:"enabled" module:"openconfig-interfaces"`
	Index	*uint32	`path:"index" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State struct {
	AdminStatus	E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus	`path:"admin-status" module:"openconfig-interfaces"`
	Counters	*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters	`path:"counters" module:"openconfig-interfaces"`
	Description	*string	`path:"description" module:"openconfig-interfaces"`
	Enabled	*bool	`path:"enabled" module:"openconfig-interfaces"`
	Ifindex	*uint32	`path:"ifindex" module:"openconfig-interfaces"`
	Index	*uint32	`path:"index" module:"openconfig-interfaces"`
	LastChange	*uint64	`path:"last-change" module:"openconfig-interfaces"`
	Logical	*bool	`path:"logical" module:"openconfig-interfaces"`
	Name	*string	`path:"name" module:"openconfig-interfaces"`
	OperStatus	E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus	`path:"oper-status" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/state/counters YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters struct {
	CarrierTransitions	*uint64	`path:"carrier-transitions" module:"openconfig-interfaces"`
	InBroadcastPkts	*uint64	`path:"in-broadcast-pkts" module:"openconfig-interfaces"`
	InDiscards	*uint64	`path:"in-discards" module:"openconfig-interfaces"`
	InErrors	*uint64	`path:"in-errors" module:"openconfig-interfaces"`
	InFcsErrors	*uint64	`path:"in-fcs-errors" module:"openconfig-interfaces"`
	InMulticastPkts	*uint64	`path:"in-multicast-pkts" module:"openconfig-interfaces"`
	InOctets	*uint64	`path:"in-octets" module:"openconfig-interfaces"`
	InPkts	*uint64	`path:"in-pkts" module:"openconfig-interfaces"`
	InUnicastPkts	*uint64	`path:"in-unicast-pkts" module:"openconfig-interfaces"`
	InUnknownProtos	*uint64	`path:"in-unknown-protos" module:"openconfig-interfaces"`
	LastClear	*uint64	`path:"last-clear" module:"openconfig-interfaces"`
	OutBroadcastPkts	*uint64	`path:"out-broadcast-pkts" module:"openconfig-interfaces"`
	OutDiscards	*uint64	`path:"out-discards" module:"openconfig-interfaces"`
	OutErrors	*uint64	`path:"out-errors" module:"openconfig-interfaces"`
	OutMulticastPkts	*uint64	`path:"out-multicast-pkts" module:"openconfig-interfaces"`
	OutOctets	*uint64	`path:"out-octets" module:"openconfig-interfaces"`
	OutPkts	*uint64	`path:"out-pkts" module:"openconfig-interfaces"`
	OutUnicastPkts	*uint64	`path:"out-unicast-pkts" module:"openconfig-interfaces"`
}

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

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

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


// OpenconfigLldp_Lldp represents the /openconfig-lldp/lldp YANG schema element.
type OpenconfigLldp_Lldp struct {
	Config	*OpenconfigLldp_Lldp_Config	`path:"config" module:"openconfig-lldp"`
	Interfaces	*OpenconfigLldp_Lldp_Interfaces	`path:"interfaces" module:"openconfig-lldp"`
	State	*OpenconfigLldp_Lldp_State	`path:"state" module:"openconfig-lldp"`
}

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

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

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


// OpenconfigLldp_Lldp_Config represents the /openconfig-lldp/lldp/config YANG schema element.
type OpenconfigLldp_Lldp_Config struct {
	ChassisId	*string	`path:"chassis-id" module:"openconfig-lldp"`
	ChassisIdType	E_OpenconfigLldp_ChassisIdType	`path:"chassis-id-type" module:"openconfig-lldp"`
	Enabled	*bool	`path:"enabled" module:"openconfig-lldp"`
	HelloTimer	*uint64	`path:"hello-timer" module:"openconfig-lldp"`
	SuppressTlvAdvertisement	[]E_OpenconfigLldpTypes_LLDP_TLV	`path:"suppress-tlv-advertisement" module:"openconfig-lldp"`
	SystemDescription	*string	`path:"system-description" module:"openconfig-lldp"`
	SystemName	*string	`path:"system-name" module:"openconfig-lldp"`
}

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

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

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


// OpenconfigLldp_Lldp_Interfaces represents the /openconfig-lldp/lldp/interfaces YANG schema element.
type OpenconfigLldp_Lldp_Interfaces struct {
	Interface	map[string]*OpenconfigLldp_Lldp_Interfaces_Interface	`path:"interface" module:"openconfig-lldp"`
}

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

// NewInterface creates a new entry in the Interface list of the
// OpenconfigLldp_Lldp_Interfaces struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigLldp_Lldp_Interfaces) NewInterface(Name string) (*OpenconfigLldp_Lldp_Interfaces_Interface, error){

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

	key := Name

	// 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.Interface[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Interface", key)
	}

	t.Interface[key] = &OpenconfigLldp_Lldp_Interfaces_Interface{
		Name: &Name,
	}

	return t.Interface[key], nil
}

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

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


// OpenconfigLldp_Lldp_Interfaces_Interface represents the /openconfig-lldp/lldp/interfaces/interface YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface struct {
	Config	*OpenconfigLldp_Lldp_Interfaces_Interface_Config	`path:"config" module:"openconfig-lldp"`
	Name	*string	`path:"name" module:"openconfig-lldp"`
	Neighbors	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors	`path:"neighbors" module:"openconfig-lldp"`
	State	*OpenconfigLldp_Lldp_Interfaces_Interface_State	`path:"state" module:"openconfig-lldp"`
}

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

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

	return map[string]interface{}{
		"name": *t.Name,
	}, nil
}

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

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


// OpenconfigLldp_Lldp_Interfaces_Interface_Config represents the /openconfig-lldp/lldp/interfaces/interface/config YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Config struct {
	Enabled	*bool	`path:"enabled" module:"openconfig-lldp"`
	Name	*string	`path:"name" module:"openconfig-lldp"`
}

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

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

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


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors represents the /openconfig-lldp/lldp/interfaces/interface/neighbors YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors struct {
	Neighbor	map[string]*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor	`path:"neighbor" module:"openconfig-lldp"`
}