yang.go

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

	t.BoundaryNodeEdgePoint[key] = &TapiCommon_Context_TopologyContext_Topology_BoundaryNodeEdgePoint{
		TopologyUuid: &TopologyUuid,
		NodeUuid: &NodeUuid,
		NodeEdgePointUuid: &NodeEdgePointUuid,
	}

	return t.BoundaryNodeEdgePoint[key], nil
}

// NewLink creates a new entry in the Link list of the
// TapiCommon_Context_TopologyContext_Topology struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology) NewLink(Uuid string) (*TapiCommon_Context_TopologyContext_Topology_Link, error){

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

	key := Uuid

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

	t.Link[key] = &TapiCommon_Context_TopologyContext_Topology_Link{
		Uuid: &Uuid,
	}

	return t.Link[key], nil
}

// NewName creates a new entry in the Name list of the
// TapiCommon_Context_TopologyContext_Topology struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology) NewName(ValueName string) (*TapiCommon_Context_TopologyContext_Topology_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_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_Name{
		ValueName: &ValueName,
	}

	return t.Name[key], nil
}

// NewNode creates a new entry in the Node list of the
// TapiCommon_Context_TopologyContext_Topology struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology) NewNode(Uuid string) (*TapiCommon_Context_TopologyContext_Topology_Node, error){

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

	key := Uuid

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

	t.Node[key] = &TapiCommon_Context_TopologyContext_Topology_Node{
		Uuid: &Uuid,
	}

	return t.Node[key], nil
}

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


// TapiCommon_Context_TopologyContext_Topology_BoundaryNodeEdgePoint represents the /tapi-common/context/topology-context/topology/boundary-node-edge-point YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_BoundaryNodeEdgePoint 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_BoundaryNodeEdgePoint 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_BoundaryNodeEdgePoint) IsYANGGoStruct() {}

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


// TapiCommon_Context_TopologyContext_Topology_Link represents the /tapi-common/context/topology-context/topology/link YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link struct {
	AdministrativeState	E_TapiCommon_AdministrativeState	`path:"administrative-state" module:"tapi-topology"`
	AvailableCapacity	*TapiCommon_Context_TopologyContext_Topology_Link_AvailableCapacity	`path:"available-capacity" module:"tapi-topology"`
	CostCharacteristic	map[string]*TapiCommon_Context_TopologyContext_Topology_Link_CostCharacteristic	`path:"cost-characteristic" module:"tapi-topology"`
	DeliveryOrderCharacteristic	*string	`path:"delivery-order-characteristic" module:"tapi-topology"`
	Direction	E_TapiTopology_ForwardingDirection	`path:"direction" module:"tapi-topology"`
	ErrorCharacteristic	*string	`path:"error-characteristic" module:"tapi-topology"`
	LatencyCharacteristic	map[string]*TapiCommon_Context_TopologyContext_Topology_Link_LatencyCharacteristic	`path:"latency-characteristic" module:"tapi-topology"`
	LayerProtocolName	[]E_TapiTopology_LayerProtocolName	`path:"layer-protocol-name" module:"tapi-topology"`
	LifecycleState	E_TapiCommon_LifecycleState	`path:"lifecycle-state" module:"tapi-topology"`
	LossCharacteristic	*string	`path:"loss-characteristic" module:"tapi-topology"`
	Name	map[string]*TapiCommon_Context_TopologyContext_Topology_Link_Name	`path:"name" module:"tapi-topology"`
	NodeEdgePoint	map[TapiCommon_Context_TopologyContext_Topology_Link_NodeEdgePoint_Key]*TapiCommon_Context_TopologyContext_Topology_Link_NodeEdgePoint	`path:"node-edge-point" module:"tapi-topology"`
	OperationalState	E_TapiCommon_OperationalState	`path:"operational-state" module:"tapi-topology"`
	RepeatDeliveryCharacteristic	*string	`path:"repeat-delivery-characteristic" module:"tapi-topology"`
	ResilienceType	*TapiCommon_Context_TopologyContext_Topology_Link_ResilienceType	`path:"resilience-type" module:"tapi-topology"`
	RiskCharacteristic	map[string]*TapiCommon_Context_TopologyContext_Topology_Link_RiskCharacteristic	`path:"risk-characteristic" module:"tapi-topology"`
	ServerIntegrityProcessCharacteristic	*string	`path:"server-integrity-process-characteristic" module:"tapi-topology"`
	TotalPotentialCapacity	*TapiCommon_Context_TopologyContext_Topology_Link_TotalPotentialCapacity	`path:"total-potential-capacity" module:"tapi-topology"`
	TransitionedLayerProtocolName	[]string	`path:"transitioned-layer-protocol-name" module:"tapi-topology"`
	UnavailableTimeCharacteristic	*string	`path:"unavailable-time-characteristic" module:"tapi-topology"`
	Uuid	*string	`path:"uuid" module:"tapi-topology"`
	ValidationMechanism	map[string]*TapiCommon_Context_TopologyContext_Topology_Link_ValidationMechanism	`path:"validation-mechanism" module:"tapi-topology"`
}

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

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

// NewCostCharacteristic creates a new entry in the CostCharacteristic list of the
// TapiCommon_Context_TopologyContext_Topology_Link struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Link) NewCostCharacteristic(CostName string) (*TapiCommon_Context_TopologyContext_Topology_Link_CostCharacteristic, error){

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

	key := CostName

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

	t.CostCharacteristic[key] = &TapiCommon_Context_TopologyContext_Topology_Link_CostCharacteristic{
		CostName: &CostName,
	}

	return t.CostCharacteristic[key], nil
}

// NewLatencyCharacteristic creates a new entry in the LatencyCharacteristic list of the
// TapiCommon_Context_TopologyContext_Topology_Link struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Link) NewLatencyCharacteristic(TrafficPropertyName string) (*TapiCommon_Context_TopologyContext_Topology_Link_LatencyCharacteristic, error){

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

	key := TrafficPropertyName

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

	t.LatencyCharacteristic[key] = &TapiCommon_Context_TopologyContext_Topology_Link_LatencyCharacteristic{
		TrafficPropertyName: &TrafficPropertyName,
	}

	return t.LatencyCharacteristic[key], nil
}

// NewName creates a new entry in the Name list of the
// TapiCommon_Context_TopologyContext_Topology_Link struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Link) NewName(ValueName string) (*TapiCommon_Context_TopologyContext_Topology_Link_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_Link_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_Link_Name{
		ValueName: &ValueName,
	}

	return t.Name[key], nil
}

// NewNodeEdgePoint creates a new entry in the NodeEdgePoint list of the
// TapiCommon_Context_TopologyContext_Topology_Link struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Link) NewNodeEdgePoint(TopologyUuid string, NodeUuid string, NodeEdgePointUuid string) (*TapiCommon_Context_TopologyContext_Topology_Link_NodeEdgePoint, error){

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

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

	t.NodeEdgePoint[key] = &TapiCommon_Context_TopologyContext_Topology_Link_NodeEdgePoint{
		TopologyUuid: &TopologyUuid,
		NodeUuid: &NodeUuid,
		NodeEdgePointUuid: &NodeEdgePointUuid,
	}

	return t.NodeEdgePoint[key], nil
}

// NewRiskCharacteristic creates a new entry in the RiskCharacteristic list of the
// TapiCommon_Context_TopologyContext_Topology_Link struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Link) NewRiskCharacteristic(RiskCharacteristicName string) (*TapiCommon_Context_TopologyContext_Topology_Link_RiskCharacteristic, error){

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

	key := RiskCharacteristicName

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

	t.RiskCharacteristic[key] = &TapiCommon_Context_TopologyContext_Topology_Link_RiskCharacteristic{
		RiskCharacteristicName: &RiskCharacteristicName,
	}

	return t.RiskCharacteristic[key], nil
}

// NewValidationMechanism creates a new entry in the ValidationMechanism list of the
// TapiCommon_Context_TopologyContext_Topology_Link struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Link) NewValidationMechanism(ValidationMechanism string) (*TapiCommon_Context_TopologyContext_Topology_Link_ValidationMechanism, error){

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

	key := ValidationMechanism

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

	t.ValidationMechanism[key] = &TapiCommon_Context_TopologyContext_Topology_Link_ValidationMechanism{
		ValidationMechanism: &ValidationMechanism,
	}

	return t.ValidationMechanism[key], nil
}

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


// TapiCommon_Context_TopologyContext_Topology_Link_AvailableCapacity represents the /tapi-common/context/topology-context/topology/link/available-capacity YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_AvailableCapacity struct {
	TotalSize	*TapiCommon_Context_TopologyContext_Topology_Link_AvailableCapacity_TotalSize	`path:"total-size" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Link_AvailableCapacity_TotalSize represents the /tapi-common/context/topology-context/topology/link/available-capacity/total-size YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_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_Link_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_Link_AvailableCapacity_TotalSize) IsYANGGoStruct() {}

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


// TapiCommon_Context_TopologyContext_Topology_Link_CostCharacteristic represents the /tapi-common/context/topology-context/topology/link/cost-characteristic YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_CostCharacteristic struct {
	CostAlgorithm	*string	`path:"cost-algorithm" module:"tapi-topology"`
	CostName	*string	`path:"cost-name" module:"tapi-topology"`
	CostValue	*string	`path:"cost-value" module:"tapi-topology"`
}

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

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

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

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


// TapiCommon_Context_TopologyContext_Topology_Link_LatencyCharacteristic represents the /tapi-common/context/topology-context/topology/link/latency-characteristic YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_LatencyCharacteristic struct {
	FixedLatencyCharacteristic	*string	`path:"fixed-latency-characteristic" module:"tapi-topology"`
	JitterCharacteristic	*string	`path:"jitter-characteristic" module:"tapi-topology"`
	QueingLatencyCharacteristic	*string	`path:"queing-latency-characteristic" module:"tapi-topology"`
	TrafficPropertyName	*string	`path:"traffic-property-name" module:"tapi-topology"`
	WanderCharacteristic	*string	`path:"wander-characteristic" module:"tapi-topology"`
}

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

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


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

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

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


// TapiCommon_Context_TopologyContext_Topology_Link_NodeEdgePoint represents the /tapi-common/context/topology-context/topology/link/node-edge-point YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_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_Link_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_Link_NodeEdgePoint) IsYANGGoStruct() {}

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


// TapiCommon_Context_TopologyContext_Topology_Link_ResilienceType represents the /tapi-common/context/topology-context/topology/link/resilience-type YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_ResilienceType struct {
	ProtectionType	E_TapiTopology_ProtectionType	`path:"protection-type" module:"tapi-topology"`
	RestorationPolicy	E_TapiTopology_RestorationPolicy	`path:"restoration-policy" module:"tapi-topology"`
}

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

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


// TapiCommon_Context_TopologyContext_Topology_Link_RiskCharacteristic represents the /tapi-common/context/topology-context/topology/link/risk-characteristic YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_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_Link_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_Link_RiskCharacteristic) IsYANGGoStruct() {}

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


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

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

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


// TapiCommon_Context_TopologyContext_Topology_Link_TotalPotentialCapacity_TotalSize represents the /tapi-common/context/topology-context/topology/link/total-potential-capacity/total-size YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_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_Link_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_Link_TotalPotentialCapacity_TotalSize) IsYANGGoStruct() {}

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


// TapiCommon_Context_TopologyContext_Topology_Link_ValidationMechanism represents the /tapi-common/context/topology-context/topology/link/validation-mechanism YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Link_ValidationMechanism struct {
	LayerProtocolAdjacencyValidated	*string	`path:"layer-protocol-adjacency-validated" module:"tapi-topology"`
	ValidationMechanism	*string	`path:"validation-mechanism" module:"tapi-topology"`
	ValidationRobustness	*string	`path:"validation-robustness" module:"tapi-topology"`
}

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

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

	return map[string]interface{}{
		"validation-mechanism": *t.ValidationMechanism,
	}, nil
}

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


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

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

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


// TapiCommon_Context_TopologyContext_Topology_Node represents the /tapi-common/context/topology-context/topology/node YANG schema element.
type TapiCommon_Context_TopologyContext_Topology_Node struct {
	AdministrativeState	E_TapiCommon_AdministrativeState	`path:"administrative-state" module:"tapi-topology"`
	AggregatedNodeEdgePoint	map[TapiCommon_Context_TopologyContext_Topology_Node_AggregatedNodeEdgePoint_Key]*TapiCommon_Context_TopologyContext_Topology_Node_AggregatedNodeEdgePoint	`path:"aggregated-node-edge-point" module:"tapi-topology"`
	AvailableCapacity	*TapiCommon_Context_TopologyContext_Topology_Node_AvailableCapacity	`path:"available-capacity" module:"tapi-topology"`
	CostCharacteristic	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_CostCharacteristic	`path:"cost-characteristic" module:"tapi-topology"`
	DeliveryOrderCharacteristic	*string	`path:"delivery-order-characteristic" module:"tapi-topology"`
	EncapTopology	*TapiCommon_Context_TopologyContext_Topology_Node_EncapTopology	`path:"encap-topology" module:"tapi-topology"`
	ErrorCharacteristic	*string	`path:"error-characteristic" module:"tapi-topology"`
	LatencyCharacteristic	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_LatencyCharacteristic	`path:"latency-characteristic" module:"tapi-topology"`
	LayerProtocolName	[]E_TapiTopology_LayerProtocolName	`path:"layer-protocol-name" module:"tapi-topology"`
	LifecycleState	E_TapiCommon_LifecycleState	`path:"lifecycle-state" module:"tapi-topology"`
	LossCharacteristic	*string	`path:"loss-characteristic" module:"tapi-topology"`
	Name	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_Name	`path:"name" module:"tapi-topology"`
	NodeRuleGroup	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup	`path:"node-rule-group" module:"tapi-topology"`
	OperationalState	E_TapiCommon_OperationalState	`path:"operational-state" module:"tapi-topology"`
	OwnedNodeEdgePoint	map[string]*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint	`path:"owned-node-edge-point" module:"tapi-topology"`
	RepeatDeliveryCharacteristic	*string	`path:"repeat-delivery-characteristic" module:"tapi-topology"`
	ServerIntegrityProcessCharacteristic	*string	`path:"server-integrity-process-characteristic" module:"tapi-topology"`
	TotalPotentialCapacity	*TapiCommon_Context_TopologyContext_Topology_Node_TotalPotentialCapacity	`path:"total-potential-capacity" module:"tapi-topology"`
	UnavailableTimeCharacteristic	*string	`path:"unavailable-time-characteristic" module:"tapi-topology"`
	Uuid	*string	`path:"uuid" module:"tapi-topology"`
}

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

// TapiCommon_Context_TopologyContext_Topology_Node_AggregatedNodeEdgePoint_Key represents the key for list AggregatedNodeEdgePoint of element /tapi-common/context/topology-context/topology/node.
type TapiCommon_Context_TopologyContext_Topology_Node_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 struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node) NewAggregatedNodeEdgePoint(TopologyUuid string, NodeUuid string, NodeEdgePointUuid string) (*TapiCommon_Context_TopologyContext_Topology_Node_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_AggregatedNodeEdgePoint_Key]*TapiCommon_Context_TopologyContext_Topology_Node_AggregatedNodeEdgePoint)
	}

	key := TapiCommon_Context_TopologyContext_Topology_Node_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_AggregatedNodeEdgePoint{
		TopologyUuid: &TopologyUuid,
		NodeUuid: &NodeUuid,
		NodeEdgePointUuid: &NodeEdgePointUuid,
	}

	return t.AggregatedNodeEdgePoint[key], nil
}

// NewCostCharacteristic creates a new entry in the CostCharacteristic list of the
// TapiCommon_Context_TopologyContext_Topology_Node struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node) NewCostCharacteristic(CostName string) (*TapiCommon_Context_TopologyContext_Topology_Node_CostCharacteristic, error){

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

	key := CostName

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

	t.CostCharacteristic[key] = &TapiCommon_Context_TopologyContext_Topology_Node_CostCharacteristic{
		CostName: &CostName,
	}

	return t.CostCharacteristic[key], nil
}

// NewLatencyCharacteristic creates a new entry in the LatencyCharacteristic list of the
// TapiCommon_Context_TopologyContext_Topology_Node struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node) NewLatencyCharacteristic(TrafficPropertyName string) (*TapiCommon_Context_TopologyContext_Topology_Node_LatencyCharacteristic, error){

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

	key := TrafficPropertyName

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

	t.LatencyCharacteristic[key] = &TapiCommon_Context_TopologyContext_Topology_Node_LatencyCharacteristic{
		TrafficPropertyName: &TrafficPropertyName,
	}

	return t.LatencyCharacteristic[key], nil
}

// NewName creates a new entry in the Name list of the
// TapiCommon_Context_TopologyContext_Topology_Node struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node) NewName(ValueName string) (*TapiCommon_Context_TopologyContext_Topology_Node_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_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_Name{
		ValueName: &ValueName,
	}

	return t.Name[key], nil
}

// NewNodeRuleGroup creates a new entry in the NodeRuleGroup list of the
// TapiCommon_Context_TopologyContext_Topology_Node struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node) NewNodeRuleGroup(Uuid string) (*TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup, error){

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

	key := Uuid

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

	t.NodeRuleGroup[key] = &TapiCommon_Context_TopologyContext_Topology_Node_NodeRuleGroup{
		Uuid: &Uuid,
	}

	return t.NodeRuleGroup[key], nil
}

// NewOwnedNodeEdgePoint creates a new entry in the OwnedNodeEdgePoint list of the
// TapiCommon_Context_TopologyContext_Topology_Node struct. The keys of the list are populated from the input
// arguments.
func (t *TapiCommon_Context_TopologyContext_Topology_Node) NewOwnedNodeEdgePoint(Uuid string) (*TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint, error){

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

	key := Uuid

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

	t.OwnedNodeEdgePoint[key] = &TapiCommon_Context_TopologyContext_Topology_Node_OwnedNodeEdgePoint{
		Uuid: &Uuid,
	}

	return t.OwnedNodeEdgePoint[key], nil
}

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