generated.go

		t.Neighbor = make(map[string]*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor)
	}

	key := Id

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

	t.Neighbor[key] = &OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor{
		Id: &Id,
	}

	return t.Neighbor[key], nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors"], 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_Neighbors) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor struct {
	Capabilities	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities	`path:"capabilities" module:"openconfig-lldp"`
	Config	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Config	`path:"config" module:"openconfig-lldp"`
	CustomTlvs	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs	`path:"custom-tlvs" module:"openconfig-lldp"`
	Id	*string	`path:"id" module:"openconfig-lldp"`
	State	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_State	`path:"state" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor 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_Neighbors_Neighbor) IsYANGGoStruct() {}

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

	return map[string]interface{}{
		"id": *t.Id,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor"], 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_Neighbors_Neighbor) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/capabilities YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities struct {
	Capability	map[E_OpenconfigLldpTypes_LLDP_SYSTEM_CAPABILITY]*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability	`path:"capability" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities 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_Neighbors_Neighbor_Capabilities) IsYANGGoStruct() {}

// NewCapability creates a new entry in the Capability list of the
// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities) NewCapability(Name E_OpenconfigLldpTypes_LLDP_SYSTEM_CAPABILITY) (*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability, error){

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

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

	t.Capability[key] = &OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability{
		Name: Name,
	}

	return t.Capability[key], nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities"], 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_Neighbors_Neighbor_Capabilities) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/capabilities/capability YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability struct {
	Config	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_Config	`path:"config" module:"openconfig-lldp"`
	Name	E_OpenconfigLldpTypes_LLDP_SYSTEM_CAPABILITY	`path:"name" module:"openconfig-lldp"`
	State	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_State	`path:"state" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability 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_Neighbors_Neighbor_Capabilities_Capability) IsYANGGoStruct() {}

// ΛListKeyMap returns the keys of the OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability struct, which is a YANG list entry.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability) ΛListKeyMap() (map[string]interface{}, error) {

	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_Neighbors_Neighbor_Capabilities_Capability) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability"], 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_Neighbors_Neighbor_Capabilities_Capability) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_Config represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/capabilities/capability/config YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_Config struct {
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_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_Neighbors_Neighbor_Capabilities_Capability_Config) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_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_Neighbors_Neighbor_Capabilities_Capability_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_State represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/capabilities/capability/state YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_State struct {
	Enabled	*bool	`path:"enabled" module:"openconfig-lldp"`
	Name	E_OpenconfigLldpTypes_LLDP_SYSTEM_CAPABILITY	`path:"name" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_State 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_Neighbors_Neighbor_Capabilities_Capability_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_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 *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Capabilities_Capability_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Config represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/config YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Config struct {
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_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_Neighbors_Neighbor_Config) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_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_Neighbors_Neighbor_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/custom-tlvs YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs struct {
	Tlv	map[OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Key]*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv	`path:"tlv" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs 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_Neighbors_Neighbor_CustomTlvs) IsYANGGoStruct() {}

// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Key represents the key for list Tlv of element /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/custom-tlvs.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Key struct {
	Type	int32	`path:"type"`
	Oui	string	`path:"oui"`
	OuiSubtype	string	`path:"oui-subtype"`
}

// NewTlv creates a new entry in the Tlv list of the
// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs) NewTlv(Type int32, Oui string, OuiSubtype string) (*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv, error){

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

	key := OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Key{
		Type: Type,
		Oui: Oui,
		OuiSubtype: OuiSubtype,
	}

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

	t.Tlv[key] = &OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv{
		Type: &Type,
		Oui: &Oui,
		OuiSubtype: &OuiSubtype,
	}

	return t.Tlv[key], nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs"], 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_Neighbors_Neighbor_CustomTlvs) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/custom-tlvs/tlv YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv struct {
	Config	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Config	`path:"config" module:"openconfig-lldp"`
	Oui	*string	`path:"oui" module:"openconfig-lldp"`
	OuiSubtype	*string	`path:"oui-subtype" module:"openconfig-lldp"`
	State	*OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_State	`path:"state" module:"openconfig-lldp"`
	Type	*int32	`path:"type" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv 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_Neighbors_Neighbor_CustomTlvs_Tlv) IsYANGGoStruct() {}

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

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

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

	return map[string]interface{}{
		"oui": *t.Oui,
		"oui-subtype": *t.OuiSubtype,
		"type": *t.Type,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv"], 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_Neighbors_Neighbor_CustomTlvs_Tlv) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Config represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/custom-tlvs/tlv/config YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Config struct {
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_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_Neighbors_Neighbor_CustomTlvs_Tlv_Config) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_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_Neighbors_Neighbor_CustomTlvs_Tlv_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_State represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/custom-tlvs/tlv/state YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_State struct {
	Oui	*string	`path:"oui" module:"openconfig-lldp"`
	OuiSubtype	*string	`path:"oui-subtype" module:"openconfig-lldp"`
	Type	*int32	`path:"type" module:"openconfig-lldp"`
	Value	Binary	`path:"value" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_State 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_Neighbors_Neighbor_CustomTlvs_Tlv_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_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 *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_CustomTlvs_Tlv_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_State represents the /openconfig-lldp/lldp/interfaces/interface/neighbors/neighbor/state YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_State struct {
	Age	*uint64	`path:"age" module:"openconfig-lldp"`
	ChassisId	*string	`path:"chassis-id" module:"openconfig-lldp"`
	ChassisIdType	E_OpenconfigLldp_ChassisIdType	`path:"chassis-id-type" module:"openconfig-lldp"`
	Id	*string	`path:"id" module:"openconfig-lldp"`
	LastUpdate	*int64	`path:"last-update" module:"openconfig-lldp"`
	ManagementAddress	*string	`path:"management-address" module:"openconfig-lldp"`
	ManagementAddressType	*string	`path:"management-address-type" module:"openconfig-lldp"`
	PortDescription	*string	`path:"port-description" module:"openconfig-lldp"`
	PortId	*string	`path:"port-id" module:"openconfig-lldp"`
	PortIdType	E_OpenconfigLldp_PortIdType	`path:"port-id-type" module:"openconfig-lldp"`
	SystemDescription	*string	`path:"system-description" module:"openconfig-lldp"`
	SystemName	*string	`path:"system-name" module:"openconfig-lldp"`
	Ttl	*uint16	`path:"ttl" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_State 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_Neighbors_Neighbor_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_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 *OpenconfigLldp_Lldp_Interfaces_Interface_Neighbors_Neighbor_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


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

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_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 (*OpenconfigLldp_Lldp_Interfaces_Interface_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_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 *OpenconfigLldp_Lldp_Interfaces_Interface_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_Interfaces_Interface_State_Counters represents the /openconfig-lldp/lldp/interfaces/interface/state/counters YANG schema element.
type OpenconfigLldp_Lldp_Interfaces_Interface_State_Counters struct {
	FrameDiscard	*uint64	`path:"frame-discard" module:"openconfig-lldp"`
	FrameErrorIn	*uint64	`path:"frame-error-in" module:"openconfig-lldp"`
	FrameErrorOut	*uint64	`path:"frame-error-out" module:"openconfig-lldp"`
	FrameIn	*uint64	`path:"frame-in" module:"openconfig-lldp"`
	FrameOut	*uint64	`path:"frame-out" module:"openconfig-lldp"`
	LastClear	*string	`path:"last-clear" module:"openconfig-lldp"`
	TlvDiscard	*uint64	`path:"tlv-discard" module:"openconfig-lldp"`
	TlvUnknown	*uint64	`path:"tlv-unknown" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_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 (*OpenconfigLldp_Lldp_Interfaces_Interface_State_Counters) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_Interfaces_Interface_State_Counters) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_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 *OpenconfigLldp_Lldp_Interfaces_Interface_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_State represents the /openconfig-lldp/lldp/state YANG schema element.
type OpenconfigLldp_Lldp_State struct {
	ChassisId	*string	`path:"chassis-id" module:"openconfig-lldp"`
	ChassisIdType	E_OpenconfigLldp_ChassisIdType	`path:"chassis-id-type" module:"openconfig-lldp"`
	Counters	*OpenconfigLldp_Lldp_State_Counters	`path:"counters" 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_State 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_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_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 *OpenconfigLldp_Lldp_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigLldp_Lldp_State_Counters represents the /openconfig-lldp/lldp/state/counters YANG schema element.
type OpenconfigLldp_Lldp_State_Counters struct {
	EntriesAgedOut	*uint64	`path:"entries-aged-out" module:"openconfig-lldp"`
	FrameDiscard	*uint64	`path:"frame-discard" module:"openconfig-lldp"`
	FrameErrorIn	*uint64	`path:"frame-error-in" module:"openconfig-lldp"`
	FrameIn	*uint64	`path:"frame-in" module:"openconfig-lldp"`
	FrameOut	*uint64	`path:"frame-out" module:"openconfig-lldp"`
	LastClear	*string	`path:"last-clear" module:"openconfig-lldp"`
	TlvAccepted	*uint64	`path:"tlv-accepted" module:"openconfig-lldp"`
	TlvDiscard	*uint64	`path:"tlv-discard" module:"openconfig-lldp"`
	TlvUnknown	*uint64	`path:"tlv-unknown" module:"openconfig-lldp"`
}

// IsYANGGoStruct ensures that OpenconfigLldp_Lldp_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 (*OpenconfigLldp_Lldp_State_Counters) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigLldp_Lldp_State_Counters) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigLldp_Lldp_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 *OpenconfigLldp_Lldp_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components represents the /openconfig-platform/components YANG schema element.
type OpenconfigPlatform_Components struct {
	Component	map[string]*OpenconfigPlatform_Components_Component	`path:"component" module:"openconfig-platform"`
}

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

// NewComponent creates a new entry in the Component list of the
// OpenconfigPlatform_Components struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigPlatform_Components) NewComponent(Name string) (*OpenconfigPlatform_Components_Component, error){

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

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

	t.Component[key] = &OpenconfigPlatform_Components_Component{
		Name: &Name,
	}

	return t.Component[key], nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components"], 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 *OpenconfigPlatform_Components) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component represents the /openconfig-platform/components/component YANG schema element.
type OpenconfigPlatform_Components_Component struct {
	Backplane	*OpenconfigPlatform_Components_Component_Backplane	`path:"backplane" module:"openconfig-platform"`
	Chassis	*OpenconfigPlatform_Components_Component_Chassis	`path:"chassis" module:"openconfig-platform"`
	Config	*OpenconfigPlatform_Components_Component_Config	`path:"config" module:"openconfig-platform"`
	Cpu	*OpenconfigPlatform_Components_Component_Cpu	`path:"cpu" module:"openconfig-platform"`
	Fabric	*OpenconfigPlatform_Components_Component_Fabric	`path:"fabric" module:"openconfig-platform"`
	Fan	*OpenconfigPlatform_Components_Component_Fan	`path:"fan" module:"openconfig-platform"`
	IntegratedCircuit	*OpenconfigPlatform_Components_Component_IntegratedCircuit	`path:"integrated-circuit" module:"openconfig-platform"`
	Name	*string	`path:"name" module:"openconfig-platform"`
	OpticalChannel	*OpenconfigPlatform_Components_Component_OpticalChannel	`path:"optical-channel" module:"openconfig-terminal-device"`
	Port	*OpenconfigPlatform_Components_Component_Port	`path:"port" module:"openconfig-platform"`
	PowerSupply	*OpenconfigPlatform_Components_Component_PowerSupply	`path:"power-supply" module:"openconfig-platform"`
	Properties	*OpenconfigPlatform_Components_Component_Properties	`path:"properties" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_State	`path:"state" module:"openconfig-platform"`
	Storage	*OpenconfigPlatform_Components_Component_Storage	`path:"storage" module:"openconfig-platform"`
	Subcomponents	*OpenconfigPlatform_Components_Component_Subcomponents	`path:"subcomponents" module:"openconfig-platform"`
	Transceiver	*OpenconfigPlatform_Components_Component_Transceiver	`path:"transceiver" module:"openconfig-platform-transceiver"`
}

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

// ΛListKeyMap returns the keys of the OpenconfigPlatform_Components_Component struct, which is a YANG list entry.
func (t *OpenconfigPlatform_Components_Component) Λ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 *OpenconfigPlatform_Components_Component) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component"], 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 *OpenconfigPlatform_Components_Component) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Backplane represents the /openconfig-platform/components/component/backplane YANG schema element.
type OpenconfigPlatform_Components_Component_Backplane struct {
	Config	*OpenconfigPlatform_Components_Component_Backplane_Config	`path:"config" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_Backplane_State	`path:"state" module:"openconfig-platform"`
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Backplane) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Backplane"], 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 *OpenconfigPlatform_Components_Component_Backplane) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Backplane_Config represents the /openconfig-platform/components/component/backplane/config YANG schema element.
type OpenconfigPlatform_Components_Component_Backplane_Config struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Backplane_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Backplane_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 *OpenconfigPlatform_Components_Component_Backplane_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Backplane_State represents the /openconfig-platform/components/component/backplane/state YANG schema element.
type OpenconfigPlatform_Components_Component_Backplane_State struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Backplane_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Backplane_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 *OpenconfigPlatform_Components_Component_Backplane_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Chassis represents the /openconfig-platform/components/component/chassis YANG schema element.
type OpenconfigPlatform_Components_Component_Chassis struct {
	Config	*OpenconfigPlatform_Components_Component_Chassis_Config	`path:"config" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_Chassis_State	`path:"state" module:"openconfig-platform"`
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Chassis) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Chassis"], 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 *OpenconfigPlatform_Components_Component_Chassis) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Chassis_Config represents the /openconfig-platform/components/component/chassis/config YANG schema element.
type OpenconfigPlatform_Components_Component_Chassis_Config struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Chassis_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Chassis_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 *OpenconfigPlatform_Components_Component_Chassis_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Chassis_State represents the /openconfig-platform/components/component/chassis/state YANG schema element.
type OpenconfigPlatform_Components_Component_Chassis_State struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Chassis_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Chassis_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 *OpenconfigPlatform_Components_Component_Chassis_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Config represents the /openconfig-platform/components/component/config YANG schema element.
type OpenconfigPlatform_Components_Component_Config struct {
	Name	*string	`path:"name" module:"openconfig-platform"`
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_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 *OpenconfigPlatform_Components_Component_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Cpu represents the /openconfig-platform/components/component/cpu YANG schema element.
type OpenconfigPlatform_Components_Component_Cpu struct {
	Config	*OpenconfigPlatform_Components_Component_Cpu_Config	`path:"config" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_Cpu_State	`path:"state" module:"openconfig-platform"`
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Cpu) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Cpu"], 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 *OpenconfigPlatform_Components_Component_Cpu) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Cpu_Config represents the /openconfig-platform/components/component/cpu/config YANG schema element.
type OpenconfigPlatform_Components_Component_Cpu_Config struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Cpu_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Cpu_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 *OpenconfigPlatform_Components_Component_Cpu_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Cpu_State represents the /openconfig-platform/components/component/cpu/state YANG schema element.
type OpenconfigPlatform_Components_Component_Cpu_State struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Cpu_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Cpu_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 *OpenconfigPlatform_Components_Component_Cpu_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Fabric represents the /openconfig-platform/components/component/fabric YANG schema element.
type OpenconfigPlatform_Components_Component_Fabric struct {
	Config	*OpenconfigPlatform_Components_Component_Fabric_Config	`path:"config" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_Fabric_State	`path:"state" module:"openconfig-platform"`
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Fabric) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Fabric"], 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 *OpenconfigPlatform_Components_Component_Fabric) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Fabric_Config represents the /openconfig-platform/components/component/fabric/config YANG schema element.
type OpenconfigPlatform_Components_Component_Fabric_Config struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Fabric_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Fabric_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 *OpenconfigPlatform_Components_Component_Fabric_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Fabric_State represents the /openconfig-platform/components/component/fabric/state YANG schema element.
type OpenconfigPlatform_Components_Component_Fabric_State struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Fabric_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Fabric_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 *OpenconfigPlatform_Components_Component_Fabric_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Fan represents the /openconfig-platform/components/component/fan YANG schema element.
type OpenconfigPlatform_Components_Component_Fan struct {
	Config	*OpenconfigPlatform_Components_Component_Fan_Config	`path:"config" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_Fan_State	`path:"state" module:"openconfig-platform"`
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Fan) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Fan"], 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 *OpenconfigPlatform_Components_Component_Fan) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Fan_Config represents the /openconfig-platform/components/component/fan/config YANG schema element.
type OpenconfigPlatform_Components_Component_Fan_Config struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Fan_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Fan_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 *OpenconfigPlatform_Components_Component_Fan_Config) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_Fan_State represents the /openconfig-platform/components/component/fan/state YANG schema element.
type OpenconfigPlatform_Components_Component_Fan_State struct {
}

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

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigPlatform_Components_Component_Fan_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigPlatform_Components_Component_Fan_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 *OpenconfigPlatform_Components_Component_Fan_State) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }


// OpenconfigPlatform_Components_Component_IntegratedCircuit represents the /openconfig-platform/components/component/integrated-circuit YANG schema element.
type OpenconfigPlatform_Components_Component_IntegratedCircuit struct {
	Config	*OpenconfigPlatform_Components_Component_IntegratedCircuit_Config	`path:"config" module:"openconfig-platform"`
	State	*OpenconfigPlatform_Components_Component_IntegratedCircuit_State	`path:"state" module:"openconfig-platform"`
}

// IsYANGGoStruct ensures that OpenconfigPlatform_Components_Component_IntegratedCircuit implements the yang.GoStruct