yang.go

// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_LatencyCharacteristic) IsYANGGoStruct() {}

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

	return map[string]interface{}{
		"traffic-property-name": *t.TrafficPropertyName,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Name represents the /tapi-common/context/topology-context/topology/node/node-rule-group/name YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Name struct {
	Value	*string	`path:"value" module:"tapi-topology"`
	ValueName	*string	`path:"value-name" module:"tapi-topology"`
}

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

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

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_NodeEdgePoint represents the /tapi-common/context/topology-context/topology/node/node-rule-group/node-edge-point YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_NodeEdgePoint struct {
	NodeEdgePointUuid	*string	`path:"node-edge-point-uuid" module:"tapi-topology"`
	NodeUuid	*string	`path:"node-uuid" module:"tapi-topology"`
	TopologyUuid	*string	`path:"topology-uuid" module:"tapi-topology"`
}

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

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

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

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

	return map[string]interface{}{
		"node-edge-point-uuid": *t.NodeEdgePointUuid,
		"node-uuid": *t.NodeUuid,
		"topology-uuid": *t.TopologyUuid,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_RiskCharacteristic represents the /tapi-common/context/topology-context/topology/node/node-rule-group/risk-characteristic YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_RiskCharacteristic struct {
	RiskCharacteristicName	*string	`path:"risk-characteristic-name" module:"tapi-topology"`
	RiskIdentifierList	[]string	`path:"risk-identifier-list" module:"tapi-topology"`
}

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

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

	return map[string]interface{}{
		"risk-characteristic-name": *t.RiskCharacteristicName,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule represents the /tapi-common/context/topology-context/topology/node/node-rule-group/rule YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule struct {
	CepDirection	[]E_TapiTopology_PortDirection	`path:"cep-direction" module:"tapi-topology"`
	CepPortRole	[]*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_CepPortRole	`path:"cep-port-role" module:"tapi-topology"`
	ComplexRule	[]string	`path:"complex-rule" module:"tapi-topology"`
	ConnectionSpecReference	[]*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_ConnectionSpecReference	`path:"connection-spec-reference" module:"tapi-topology"`
	ForwardingRule	E_TapiTopology_ForwardingRule	`path:"forwarding-rule" module:"tapi-topology"`
	LayerProtocolQualifier	[]E_TapiTopology_LayerProtocolQualifier	`path:"layer-protocol-qualifier" module:"tapi-topology"`
	LocalId	*string	`path:"local-id" module:"tapi-topology"`
	Name	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_Name	`path:"name" module:"tapi-topology"`
	OverridePriority	*uint64	`path:"override-priority" module:"tapi-topology"`
	RuleType	E_TapiTopology_RuleType	`path:"rule-type" module:"tapi-topology"`
	SignalProperty	*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_SignalProperty	`path:"signal-property" module:"tapi-topology"`
}

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

// NewName creates a new entry in the Name list of the
// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule) NewName(ValueName string) (*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_Name, error){

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

	key := ValueName

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

	t.Name[key] = &TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_Name{
		ValueName: &ValueName,
	}

	return t.Name[key], nil
}

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

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_CepPortRole represents the /tapi-common/context/topology-context/topology/node/node-rule-group/rule/cep-port-role YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_CepPortRole struct {
	PortRole	[]string	`path:"port-role" module:"tapi-topology"`
	PortRoleRule	[]E_TapiTopology_PortRoleRuleOption	`path:"port-role-rule" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_ConnectionSpecReference represents the /tapi-common/context/topology-context/topology/node/node-rule-group/rule/connection-spec-reference YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_ConnectionSpecReference struct {
	ConnectionSpec	*string	`path:"connection-spec" module:"tapi-topology"`
	ConnectionSpecName	*string	`path:"connection-spec-name" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_Name represents the /tapi-common/context/topology-context/topology/node/node-rule-group/rule/name YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_Name struct {
	Value	*string	`path:"value" module:"tapi-topology"`
	ValueName	*string	`path:"value-name" module:"tapi-topology"`
}

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

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

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_SignalProperty represents the /tapi-common/context/topology-context/topology/node/node-rule-group/rule/signal-property YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_Rule_SignalProperty struct {
	ApplicableSignalValue	[]string	`path:"applicable-signal-value" module:"tapi-topology"`
	NumberOfSignalValues	*uint64	`path:"number-of-signal-values" module:"tapi-topology"`
	SignalPropertyName	*string	`path:"signal-property-name" module:"tapi-topology"`
	SignalPropertyValueRule	E_TapiTopology_SignalPropertyValueRule	`path:"signal-property-value-rule" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_TotalPotentialCapacity represents the /tapi-common/context/topology-context/topology/node/node-rule-group/total-potential-capacity YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_TotalPotentialCapacity struct {
	TotalSize	*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_TotalPotentialCapacity_TotalSize	`path:"total-size" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_TotalPotentialCapacity_TotalSize represents the /tapi-common/context/topology-context/topology/node/node-rule-group/total-potential-capacity/total-size YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup_TotalPotentialCapacity_TotalSize struct {
	Unit	E_TapiCommon_CapacityUnit	`path:"unit" module:"tapi-topology"`
	Value	*uint64	`path:"value" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint struct {
	AdministrativeState	E_TapiCommon_AdministrativeState	`path:"administrative-state" module:"tapi-topology"`
	AggregatedNodeEdgePoint	map[TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint_Key]*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint	`path:"aggregated-node-edge-point" module:"tapi-topology"`
	AvailableCapacity	*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCapacity	`path:"available-capacity" module:"tapi-topology"`
	AvailableCepLayerProtocol	map[E_TapiTopology_LayerProtocolQualifier]*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCepLayerProtocol	`path:"available-cep-layer-protocol" module:"tapi-topology"`
	LayerProtocolName	E_TapiTopology_LayerProtocolName	`path:"layer-protocol-name" module:"tapi-topology"`
	LifecycleState	E_TapiCommon_LifecycleState	`path:"lifecycle-state" module:"tapi-topology"`
	LinkPortDirection	E_TapiTopology_PortDirection	`path:"link-port-direction" module:"tapi-topology"`
	LinkPortRole	E_TapiTopology_PortRole	`path:"link-port-role" module:"tapi-topology"`
	MappedServiceInterfacePoint	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_MappedServiceInterfacePoint	`path:"mapped-service-interface-point" module:"tapi-topology"`
	Name	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_Name	`path:"name" module:"tapi-topology"`
	OperationalState	E_TapiCommon_OperationalState	`path:"operational-state" module:"tapi-topology"`
	TerminationDirection	E_TapiCommon_TerminationDirection	`path:"termination-direction" module:"tapi-topology"`
	TerminationState	E_TapiCommon_TerminationState	`path:"termination-state" module:"tapi-topology"`
	TotalPotentialCapacity	*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_TotalPotentialCapacity	`path:"total-potential-capacity" module:"tapi-topology"`
	Uuid	*string	`path:"uuid" module:"tapi-topology"`
}

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

// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint_Key represents the key for list AggregatedNodeEdgePoint of element /tapi-common/context/topology-context/topology/node/owned-node-edge-point.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint_Key struct {
	TopologyUuid	string	`path:"topology-uuid"`
	NodeUuid	string	`path:"node-uuid"`
	NodeEdgePointUuid	string	`path:"node-edge-point-uuid"`
}

// NewAggregatedNodeEdgePoint creates a new entry in the AggregatedNodeEdgePoint list of the
// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint) NewAggregatedNodeEdgePoint(TopologyUuid string, NodeUuid string, NodeEdgePointUuid string) (*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint, error){

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

	key := TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint_Key{
		TopologyUuid: TopologyUuid,
		NodeUuid: NodeUuid,
		NodeEdgePointUuid: NodeEdgePointUuid,
	}

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

	t.AggregatedNodeEdgePoint[key] = &TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint{
		TopologyUuid: &TopologyUuid,
		NodeUuid: &NodeUuid,
		NodeEdgePointUuid: &NodeEdgePointUuid,
	}

	return t.AggregatedNodeEdgePoint[key], nil
}

// NewAvailableCepLayerProtocol creates a new entry in the AvailableCepLayerProtocol list of the
// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint) NewAvailableCepLayerProtocol(LayerProtocolQualifier E_TapiTopology_LayerProtocolQualifier) (*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCepLayerProtocol, error){

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

	key := LayerProtocolQualifier

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

	t.AvailableCepLayerProtocol[key] = &TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCepLayerProtocol{
		LayerProtocolQualifier: LayerProtocolQualifier,
	}

	return t.AvailableCepLayerProtocol[key], nil
}

// NewMappedServiceInterfacePoint creates a new entry in the MappedServiceInterfacePoint list of the
// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint) NewMappedServiceInterfacePoint(ServiceInterfacePointUuid string) (*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_MappedServiceInterfacePoint, error){

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

	key := ServiceInterfacePointUuid

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

	t.MappedServiceInterfacePoint[key] = &TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_MappedServiceInterfacePoint{
		ServiceInterfacePointUuid: &ServiceInterfacePointUuid,
	}

	return t.MappedServiceInterfacePoint[key], nil
}

// NewName creates a new entry in the Name list of the
// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint) NewName(ValueName string) (*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_Name, error){

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

	key := ValueName

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

	t.Name[key] = &TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_Name{
		ValueName: &ValueName,
	}

	return t.Name[key], nil
}

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

	return map[string]interface{}{
		"uuid": *t.Uuid,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/aggregated-node-edge-point YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AggregatedNodeEdgePoint struct {
	NodeEdgePointUuid	*string	`path:"node-edge-point-uuid" module:"tapi-topology"`
	NodeUuid	*string	`path:"node-uuid" module:"tapi-topology"`
	TopologyUuid	*string	`path:"topology-uuid" module:"tapi-topology"`
}

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

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

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

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

	return map[string]interface{}{
		"node-edge-point-uuid": *t.NodeEdgePointUuid,
		"node-uuid": *t.NodeUuid,
		"topology-uuid": *t.TopologyUuid,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCapacity represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/available-capacity YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCapacity struct {
	TotalSize	*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCapacity_TotalSize	`path:"total-size" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCapacity_TotalSize represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/available-capacity/total-size YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCapacity_TotalSize struct {
	Unit	E_TapiCommon_CapacityUnit	`path:"unit" module:"tapi-topology"`
	Value	*uint64	`path:"value" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCepLayerProtocol represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/available-cep-layer-protocol YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_AvailableCepLayerProtocol struct {
	LayerProtocolQualifier	E_TapiTopology_LayerProtocolQualifier	`path:"layer-protocol-qualifier" module:"tapi-topology"`
	NumberOfCepInstances	*uint64	`path:"number-of-cep-instances" module:"tapi-topology"`
}

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

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

	return map[string]interface{}{
		"layer-protocol-qualifier": t.LayerProtocolQualifier,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_MappedServiceInterfacePoint represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/mapped-service-interface-point YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_MappedServiceInterfacePoint struct {
	ServiceInterfacePointUuid	*string	`path:"service-interface-point-uuid" module:"tapi-topology"`
}

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

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

	return map[string]interface{}{
		"service-interface-point-uuid": *t.ServiceInterfacePointUuid,
	}, nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_Name represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/name YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_Name struct {
	Value	*string	`path:"value" module:"tapi-topology"`
	ValueName	*string	`path:"value-name" module:"tapi-topology"`
}

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

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

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_TotalPotentialCapacity represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/total-potential-capacity YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_TotalPotentialCapacity struct {
	TotalSize	*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_TotalPotentialCapacity_TotalSize	`path:"total-size" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_TotalPotentialCapacity_TotalSize represents the /tapi-common/context/topology-context/topology/node/owned-node-edge-point/total-potential-capacity/total-size YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint_TotalPotentialCapacity_TotalSize struct {
	Unit	E_TapiCommon_CapacityUnit	`path:"unit" module:"tapi-topology"`
	Value	*uint64	`path:"value" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_TotalPotentialCapacity represents the /tapi-common/context/topology-context/topology/node/total-potential-capacity YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_TotalPotentialCapacity struct {
	TotalSize	*TapiCommon_Context_TopologyContext_Topology_Node_TotalPotentialCapacity_TotalSize	`path:"total-size" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Node_TotalPotentialCapacity_TotalSize represents the /tapi-common/context/topology-context/topology/node/total-potential-capacity/total-size YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node_TotalPotentialCapacity_TotalSize struct {
	Unit	E_TapiCommon_CapacityUnit	`path:"unit" module:"tapi-topology"`
	Value	*uint64	`path:"value" module:"tapi-topology"`
}

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

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


// E_TapiCommon_AdministrativeState is a derived int64 type which is used to represent
// the enumerated node TapiCommon_AdministrativeState. An additional value named
// TapiCommon_AdministrativeState_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_TapiCommon_AdministrativeState int64

// IsYANGGoEnum ensures that TapiCommon_AdministrativeState implements the yang.GoEnum
// interface. This ensures that TapiCommon_AdministrativeState can be identified as a
// mapped type for a YANG enumeration.
func (E_TapiCommon_AdministrativeState) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  TapiCommon_AdministrativeState.
func (E_TapiCommon_AdministrativeState) ΛMap() map[string]map[int64]ygot.EnumDefinition { return ΛEnum; }

// String returns a logging-friendly string for E_TapiCommon_AdministrativeState.
func (e E_TapiCommon_AdministrativeState) String() string {
	return ygot.EnumLogString(e, int64(e), "E_TapiCommon_AdministrativeState")
}

const (
	// TapiCommon_AdministrativeState_UNSET corresponds to the value UNSET of TapiCommon_AdministrativeState
	TapiCommon_AdministrativeState_UNSET E_TapiCommon_AdministrativeState = 0
	// TapiCommon_AdministrativeState_LOCKED corresponds to the value LOCKED of TapiCommon_AdministrativeState
	TapiCommon_AdministrativeState_LOCKED E_TapiCommon_AdministrativeState = 1
	// TapiCommon_AdministrativeState_UNLOCKED corresponds to the value UNLOCKED of TapiCommon_AdministrativeState
	TapiCommon_AdministrativeState_UNLOCKED E_TapiCommon_AdministrativeState = 2
)


// E_TapiCommon_CapacityUnit is a derived int64 type which is used to represent
// the enumerated node TapiCommon_CapacityUnit. An additional value named
// TapiCommon_CapacityUnit_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_TapiCommon_CapacityUnit int64

// IsYANGGoEnum ensures that TapiCommon_CapacityUnit implements the yang.GoEnum
// interface. This ensures that TapiCommon_CapacityUnit can be identified as a
// mapped type for a YANG enumeration.
func (E_TapiCommon_CapacityUnit) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  TapiCommon_CapacityUnit.
func (E_TapiCommon_CapacityUnit) ΛMap() map[string]map[int64]ygot.EnumDefinition { return ΛEnum; }

// String returns a logging-friendly string for E_TapiCommon_CapacityUnit.
func (e E_TapiCommon_CapacityUnit) String() string {
	return ygot.EnumLogString(e, int64(e), "E_TapiCommon_CapacityUnit")
}

const (
	// TapiCommon_CapacityUnit_UNSET corresponds to the value UNSET of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_UNSET E_TapiCommon_CapacityUnit = 0
	// TapiCommon_CapacityUnit_TB corresponds to the value TB of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_TB E_TapiCommon_CapacityUnit = 1
	// TapiCommon_CapacityUnit_TBPS corresponds to the value TBPS of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_TBPS E_TapiCommon_CapacityUnit = 2
	// TapiCommon_CapacityUnit_GB corresponds to the value GB of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_GB E_TapiCommon_CapacityUnit = 3
	// TapiCommon_CapacityUnit_GBPS corresponds to the value GBPS of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_GBPS E_TapiCommon_CapacityUnit = 4
	// TapiCommon_CapacityUnit_MB corresponds to the value MB of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_MB E_TapiCommon_CapacityUnit = 5
	// TapiCommon_CapacityUnit_MBPS corresponds to the value MBPS of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_MBPS E_TapiCommon_CapacityUnit = 6
	// TapiCommon_CapacityUnit_KB corresponds to the value KB of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_KB E_TapiCommon_CapacityUnit = 7
	// TapiCommon_CapacityUnit_KBPS corresponds to the value KBPS of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_KBPS E_TapiCommon_CapacityUnit = 8
	// TapiCommon_CapacityUnit_GHz corresponds to the value GHz of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_GHz E_TapiCommon_CapacityUnit = 9
	// TapiCommon_CapacityUnit_MHz corresponds to the value MHz of TapiCommon_CapacityUnit
	TapiCommon_CapacityUnit_MHz E_TapiCommon_CapacityUnit = 10
)


// E_TapiCommon_LayerProtocolName is a derived int64 type which is used to represent
// the enumerated node TapiCommon_LayerProtocolName. An additional value named
// TapiCommon_LayerProtocolName_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_TapiCommon_LayerProtocolName int64

// IsYANGGoEnum ensures that TapiCommon_LayerProtocolName implements the yang.GoEnum
// interface. This ensures that TapiCommon_LayerProtocolName can be identified as a
// mapped type for a YANG enumeration.
func (E_TapiCommon_LayerProtocolName) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  TapiCommon_LayerProtocolName.
func (E_TapiCommon_LayerProtocolName) ΛMap() map[string]map[int64]ygot.EnumDefinition { return ΛEnum; }

// String returns a logging-friendly string for E_TapiCommon_LayerProtocolName.
func (e E_TapiCommon_LayerProtocolName) String() string {
	return ygot.EnumLogString(e, int64(e), "E_TapiCommon_LayerProtocolName")
}

const (
	// TapiCommon_LayerProtocolName_UNSET corresponds to the value UNSET of TapiCommon_LayerProtocolName
	TapiCommon_LayerProtocolName_UNSET E_TapiCommon_LayerProtocolName = 0
	// TapiCommon_LayerProtocolName_ODU corresponds to the value ODU of TapiCommon_LayerProtocolName
	TapiCommon_LayerProtocolName_ODU E_TapiCommon_LayerProtocolName = 1
	// TapiCommon_LayerProtocolName_ETH corresponds to the value ETH of TapiCommon_LayerProtocolName
	TapiCommon_LayerProtocolName_ETH E_TapiCommon_LayerProtocolName = 2
	// TapiCommon_LayerProtocolName_DSR corresponds to the value DSR of TapiCommon_LayerProtocolName
	TapiCommon_LayerProtocolName_DSR E_TapiCommon_LayerProtocolName = 3
	// TapiCommon_LayerProtocolName_PHOTONIC_MEDIA corresponds to the value PHOTONIC_MEDIA of TapiCommon_LayerProtocolName
	TapiCommon_LayerProtocolName_PHOTONIC_MEDIA E_TapiCommon_LayerProtocolName = 4
)


// E_TapiCommon_LayerProtocolQualifier is a derived int64 type which is used to represent
// the enumerated node TapiCommon_LayerProtocolQualifier. An additional value named
// TapiCommon_LayerProtocolQualifier_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_TapiCommon_LayerProtocolQualifier int64

// IsYANGGoEnum ensures that TapiCommon_LayerProtocolQualifier implements the yang.GoEnum
// interface. This ensures that TapiCommon_LayerProtocolQualifier can be identified as a
// mapped type for a YANG enumeration.
func (E_TapiCommon_LayerProtocolQualifier) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  TapiCommon_LayerProtocolQualifier.
func (E_TapiCommon_LayerProtocolQualifier) ΛMap() map[string]map[int64]ygot.EnumDefinition { return ΛEnum; }

// String returns a logging-friendly string for E_TapiCommon_LayerProtocolQualifier.
func (e E_TapiCommon_LayerProtocolQualifier) String() string {
	return ygot.EnumLogString(e, int64(e), "E_TapiCommon_LayerProtocolQualifier")
}

const (
	// TapiCommon_LayerProtocolQualifier_UNSET corresponds to the value UNSET of TapiCommon_LayerProtocolQualifier
	TapiCommon_LayerProtocolQualifier_UNSET E_TapiCommon_LayerProtocolQualifier = 0
	// TapiCommon_LayerProtocolQualifier_LAYER_PROTOCOL_QUALIFIER_UNSPECIFIED corresponds to the value LAYER_PROTOCOL_QUALIFIER_UNSPECIFIED of TapiCommon_LayerProtocolQualifier
	TapiCommon_LayerProtocolQualifier_LAYER_PROTOCOL_QUALIFIER_UNSPECIFIED E_TapiCommon_LayerProtocolQualifier = 1
)


// E_TapiCommon_LifecycleState is a derived int64 type which is used to represent
// the enumerated node TapiCommon_LifecycleState. An additional value named
// TapiCommon_LifecycleState_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_TapiCommon_LifecycleState int64

// IsYANGGoEnum ensures that TapiCommon_LifecycleState implements the yang.GoEnum
// interface. This ensures that TapiCommon_LifecycleState can be identified as a
// mapped type for a YANG enumeration.
func (E_TapiCommon_LifecycleState) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  TapiCommon_LifecycleState.
func (E_TapiCommon_LifecycleState) ΛMap() map[string]map[int64]ygot.EnumDefinition { return ΛEnum; }

// String returns a logging-friendly string for E_TapiCommon_LifecycleState.
func (e E_TapiCommon_LifecycleState) String() string {
	return ygot.EnumLogString(e, int64(e), "E_TapiCommon_LifecycleState")
}

const (
	// TapiCommon_LifecycleState_UNSET corresponds to the value UNSET of TapiCommon_LifecycleState
	TapiCommon_LifecycleState_UNSET E_TapiCommon_LifecycleState = 0
	// TapiCommon_LifecycleState_PLANNED corresponds to the value PLANNED of TapiCommon_LifecycleState
	TapiCommon_LifecycleState_PLANNED E_TapiCommon_LifecycleState = 1
	// TapiCommon_LifecycleState_POTENTIAL_AVAILABLE corresponds to the value POTENTIAL_AVAILABLE of TapiCommon_LifecycleState
	TapiCommon_LifecycleState_POTENTIAL_AVAILABLE E_TapiCommon_LifecycleState = 2
	// TapiCommon_LifecycleState_POTENTIAL_BUSY corresponds to the value POTENTIAL_BUSY of TapiCommon_LifecycleState
	TapiCommon_LifecycleState_POTENTIAL_BUSY E_TapiCommon_LifecycleState = 3
	// TapiCommon_LifecycleState_INSTALLED corresponds to the value INSTALLED of TapiCommon_LifecycleState
	TapiCommon_LifecycleState_INSTALLED E_TapiCommon_LifecycleState = 4
	// TapiCommon_LifecycleState_PENDING_REMOVAL corresponds to the value PENDING_REMOVAL of TapiCommon_LifecycleState
	TapiCommon_LifecycleState_PENDING_REMOVAL E_TapiCommon_LifecycleState = 5
)