diff --git a/yang-models/_3gpp-5g-common-yang-types.yang b/yang-models/_3gpp-5g-common-yang-types.yang index 0b96e49cbc8bebf6bbba994590ba3176518c6c32..40af813a2cbd40a1fba2f1b041239388cbc88f01 100755 --- a/yang-models/_3gpp-5g-common-yang-types.yang +++ b/yang-models/_3gpp-5g-common-yang-types.yang @@ -15,6 +15,7 @@ module _3gpp-5g-common-yang-types { TTA, TTC). All rights reserved."; reference "3GPP TS 28.541"; + revision 2026-03-25 { reference "CR-"; } revision 2026-01-25 { reference "CR-0060"; } // common for R19, R20 revision 2025-11-07 { reference CR-1640 ; } revision 2025-11-02 { reference CR-1658 ; } @@ -179,6 +180,112 @@ module _3gpp-5g-common-yang-types { } } + grouping SupiRangeGrp { + description "This <> represents a range of SUPIs."; + leaf start { + description "First value identifying the start of a SUPI range."; + type string { + pattern '^[0-9]+$'; + } + } + leaf end { + description "Last value identifying the end of a SUPI range."; + type string { + pattern '^[0-9]+$'; + } + } + leaf pattern { + description "Pattern representing the set of SUPIs belonging to + this range."; + type string; + } + } + + grouping IdentityRangeGrp { + description "This <> represents a range of identities."; + leaf start { + description "First value identifying the start of an identity range."; + type string { + pattern '^[0-9]+$'; + } + } + leaf end { + description "Last value identifying the end of an identity range."; + type string; + } + leaf pattern { + description "Pattern representing the set of identities belonging to + this range."; + type string; + } + } + + grouping InternalGroupIdRangeGrp { + description "This data type represents a range of Group + IDs (internal group identities), either based on a + numeric range, or based on regular-expression + matching. (See TS 29.510)."; + reference "3GPP TS 28.541 clause 5.3.132"; + + leaf start { + description "It indicates first value identifying + the start of an identity range, to be used when + the range of identities can be represented as a + consecutive numeric range."; + type string; + } + + leaf end { + description "It indicates last value identifying + the end of an identity range, to be used when + the range of identities can be represented as a + consecutive numeric range."; + type string; + } + + leaf pattern { + description "It indicates pattern (regular + expression according to the ECMA-262 dialect) + representing the set of identities belonging to + this range. An identity value is considered part + of the range if and only if the identity string + fully matches the regular expression."; + type string; + } + } + + grouping SupportedVendorSpecificFeaturesGrp { + description "This <> represents a map of Vendor-Specific + features, where the key of the map is the IANA-assigned SMI + Network Management Private Enterprise Codes and the value of each + entry of the map shall be a list (array) of VendorSpecificFeature + objects as defined in clause 5.3.247."; + reference "3GPP TS 29.510 clause 5.3.247"; + + list supportedVendorSpecificFeatures { + description "It indicates a map of Vendor-Specific features, where the + key of the map is the IANA-assigned SMI Network Management Private + Enterprise Codes and the value of each entry of the map shall be + a list (array) of VendorSpecificFeature objects as defined + in the clause 5.3.247."; + key "enterpriseCode"; + + leaf enterpriseCode { + type uint32; + description "IANA-assigned SMI Network Management Private + Enterprise Code"; + } + + list vendorSpecificFeature { + key "featureName"; + config false; + description "VendorSpecificFeature objects as defined + in the clause 5.3.247."; + uses VendorSpecificFeatureGrp; + } + } + } + grouping SnssaiExtensionGrp { list sdRanges { min-elements 1; @@ -596,6 +703,87 @@ module _3gpp-5g-common-yang-types { type inet:host; } } + grouping RuleSetGrp { + description "This data type represents list of rules specifying whether + access/scopes are allowed/denied for NF-Consumers."; + reference "3GPP TS 29.510 clause 6.2.6.2.121"; + + leaf priority { + description "It indicates the unique Priority of the rule. Lower value + means higher priority."; + mandatory true; + type uint32; + } + + list plmns { + description "It indicates PLMNs allowed/dis-allowed to access the + service instance. When absent, NF-Consumers of all PLMNs are + assumed to match this criteria."; + key "mcc mnc"; + uses types3gpp:PLMNId; + } + + list snpns { + description "It indicates SNPNs allowed/dis-allowed to access the + service instance. When absent, NF-Consumers of all SNPNs are + assumed to match this criteria."; + key "mcc mnc"; + uses PlmnIdNid; + } + + leaf-list nfTypes { + description "It indicates type of the NFs allowed/dis-allowed to + access the service instance. When absent, NF-Consumers of all + nfTypes are assumed to match this criteria."; + type types3gpp:NfType; + } + + leaf-list nfDomains { + description "It represents pattern (regular expression according to + the ECMA-262 dialect) representing the NF domain names within the + PLMN of the NRF allowed/dis-allowed to access the service instance. + When absent, NF-Consumers of all nfDomains are assumed to match + this criteria."; + type string; + } + + list nssais { + description "It represents S-NSSAIs of the NF-Consumers + allowed/dis-allowed to access the service instance. When absent, + NF-Consumers of all slices are assumed to match this criteria."; + key idx; + leaf idx { type uint32; } + uses ExtSnssaiGrp; + } + + leaf-list nfInstances { + description "It represents NF-Instance IDs of the NF-Consumers + allowed/dis-allowed to access the NF/NF-Service instance. When + absent, all the NF-Consumers are assumed to match this criteria."; + type string; + } + + leaf-list scopes { + description "It represents list of scopes allowed or denied to the + NF-Consumers matching the rule. The scopes shall be any of those + defined in the API that defines the current service. When absent, + the NF-Consumer is allowed or denied full access to all the + resources/operations of service instance."; + type string; + } + + leaf action { + description "It specifies whether the scopes/access mentioned are + allowed or denied for a specific NF-Consumer. + ALLOW: The NF consumer is allowed to access NF producer. + DENY: The NF consumer is not allowed to access NF Producer."; + mandatory true; + type enumeration { + enum ALLOW; + enum DENY; + } + } + } grouping LocationInfoGrp { description "This data type contains location information diff --git a/yang-models/_3gpp-5gc-nrm-aiot.yang b/yang-models/_3gpp-5gc-nrm-aiot.yang index be123060a171542c252449387fffffacf19cc2ff..74fed3b791a5fde66c02879f7ca33e780a6cbdca 100644 --- a/yang-models/_3gpp-5gc-nrm-aiot.yang +++ b/yang-models/_3gpp-5gc-nrm-aiot.yang @@ -14,11 +14,12 @@ module _3gpp-5gc-nrm-aiot { contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; description "Defines the YANG mapping AIOT (Ambient power-enabled Internet of Things). - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.541 3GPP TS 23.369"; + revision 2026-03-19 { reference "CR-1695 CR-1694"; } //common r19-20 revision 2025-11-01 { reference CR-1640; } grouping ServedAIOTAreaIDGrp { @@ -169,6 +170,30 @@ module _3gpp-5gc-nrm-aiot { ////////////////////////////////////////////////////////////////////// + grouping AdmInfoGrp { + description "Represents the datatype AdmInfo"; + + leaf-list deviceIdList { + type string; + description "This attribute represents a list of device IDs served by + ADM as defined in TS 29.510 [23]. The format of String is specified + in TS 29.510."; + } + + leaf devIdRegEx { + type string; + description "This attribute represents a regular expression (according to + the ECMA-262 dialect) identifying the set of device IDs served by + the ADM as defined in TS 29.510."; + } + + leaf-list afIdList { + type string; + description "This attribute represents a list of AF IDs served by ADM as + defined in TS 29.510."; + } + } + grouping ADMFunctionGrp { description "Attributes of the IOC ADMFunction"; @@ -200,6 +225,16 @@ module _3gpp-5gc-nrm-aiot { description "This parameter defines profile for managed NF"; reference "3gpp TS 23.501"; } + + list admInfo { + description "This attribute represents ADM-specific information for + management purposes. The information carried by this attribute is + aligned with the ADM-related information defined in TS 29.510."; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses AdmInfoGrp; + } } feature ADMFunctionUnderManagedElement { diff --git a/yang-models/_3gpp-5gc-nrm-ausffunction.yang b/yang-models/_3gpp-5gc-nrm-ausffunction.yang index 3f02fd5ae2aa6421ebb22dce2ee09354264d01f4..5a9e21903deb6441d825340c3f49ce409163cc79 100755 --- a/yang-models/_3gpp-5gc-nrm-ausffunction.yang +++ b/yang-models/_3gpp-5gc-nrm-ausffunction.yang @@ -66,7 +66,7 @@ module _3gpp-5gc-nrm-ausffunction { by the PCF instance."; key idx; leaf idx { type uint32 ; } - uses mnfp3gpp:SupiRangeGrp; + uses types5g3gpp:SupiRangeGrp; } leaf-list routingIndicators { diff --git a/yang-models/_3gpp-5gc-nrm-chffunction.yang b/yang-models/_3gpp-5gc-nrm-chffunction.yang new file mode 100755 index 0000000000000000000000000000000000000000..f1f6be1eebe36981e4a4ec33acf1f7ec97d4ed58 --- /dev/null +++ b/yang-models/_3gpp-5gc-nrm-chffunction.yang @@ -0,0 +1,143 @@ +module _3gpp-5gc-nrm-chffunction { + yang-version 1.1; + namespace urn:3gpp:sa5:_3gpp-5gc-nrm-chffunction; + prefix chf3gpp; + + import _3gpp-common-managed-function { prefix mf3gpp; } + import _3gpp-common-managed-element { prefix me3gpp; } + import _3gpp-common-yang-types { prefix types3gpp; } + import _3gpp-5g-common-yang-types { prefix types5g3gpp; } + import _3gpp-common-top { prefix top3gpp; } + import _3gpp-5gc-nrm-managed-nfprofile { prefix mnfp3gpp; } + import ietf-inet-types { prefix inet; } + + organization "3gpp SA5"; + contact + "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; + description "This IOC represents the CHF function. For more + information about the CHF, see TS 23.501 and + TS 32.240. + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, + CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; + reference "3GPP TS 28.541"; + + revision 2026-03-25 { reference "CR-"; } + + grouping ChfInfoGrp { + description "This data type represents the Specific + data for the CHF. + (See clause 6.1.6.2.32 TS 29.510)."; + + list supiRangeList { + description "List of ranges of SUPIs that can be + served by the CHF instance. If not provided, + the CHF can serve any SUPI."; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:SupiRangeGrp; + } + + list gpsiRangeList { + description "List of ranges of GPSI that can be + served by the CHF instance. If not provided, + the CHF can serve any GPSI."; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:IdentityRangeGrp; + } + + list plmnRangeList { + description "List of ranges of PLMNs (including + the PLMN IDs of the CHF instance) that can be + served by the CHF instance. If not provided, + the CHF can serve any PLMN."; + key "mcc mnc"; + uses types3gpp:PLMNId; + } + + leaf groupId { + description "It represents the identity of the CHF + group that is served by the CHF instance. If not + provided, the CHF instance does not pertain to + any CHF group."; + type string; + } + + leaf primaryChfInstance { + description "This attribute represents the NF + Instance Id of the primary CHF instance. This + attribute shall be absent if the + secondaryChfInstance is present."; + type string; + } + + leaf secondaryChfInstance { + description "This attribute represents the NF + Instance Id of the secondary CHF instance. + This attribute shall be absent if the + primaryChfInstance is present."; + type string; + } + } + + grouping CHFFunctionGrp { + description "Represents the CHFFunction IOC."; + uses mf3gpp:ManagedFunctionGrp; + + list pLMNInfoList { + description "It defines the PLMN(s) of a Network + Function."; + key "mcc mnc sd sst"; + min-elements 1; + uses types5g3gpp:PLMNInfo; + } + + leaf sBIFQDN { + description "The FQDN of the registered NF instance + in the service-based interface."; + type inet:domain-name; + } + + list managedNFProfile { + key idx; + leaf idx { type uint32; } + min-elements 1; + max-elements 1; + description "Profile definition of a Managed NF + (See TS 23.501)."; + uses mnfp3gpp:ManagedNFProfileGrp; + } + + list commModelList { + min-elements 1; + key "groupId"; + description "Specifies a list of commModel. It can + be used by NF and NF services to interact with + each other in 5G Core network."; + reference "3GPP TS 23.501"; + uses types5g3gpp:CommModel; + } + + list chfInfo { + description "This attribute represents information + of a CHF NF Instance."; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses ChfInfoGrp; + } + } + + augment "/me3gpp:ManagedElement" { + list CHFFunction { + description "5G Core CHF Function"; + reference "3GPP TS 28.541"; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses CHFFunctionGrp; + } + uses mf3gpp:ManagedFunctionContainedClasses; + } + } +} diff --git a/yang-models/_3gpp-5gc-nrm-ep.yang b/yang-models/_3gpp-5gc-nrm-ep.yang index 52cd3f5b6f7d36b1624cb901c729c98415f17e3d..03e8cca67e57c954b3f8011ae95acbada4be0a6c 100755 --- a/yang-models/_3gpp-5gc-nrm-ep.yang +++ b/yang-models/_3gpp-5gc-nrm-ep.yang @@ -23,6 +23,10 @@ module _3gpp-5gc-nrm-ep { import _3gpp-common-yang-types { prefix types3gpp; } import _3gpp-common-top { prefix top3gpp; } import ietf-inet-types { prefix inet; } + import _3gpp-5gc-nrm-gmlcfunction { prefix gmlc3gpp;} + import _3gpp-5gc-nrm-nwdaffunction { prefix nwdaf3gpp; } + import _3gpp-5gc-nrm-scpfunction {prefix scp3gpp;} + import _3gpp-5gc-nrm-neffunction { prefix nef3gpp; } organization "3GPP SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; @@ -176,10 +180,6 @@ module _3gpp-5gc-nrm-ep { uses eprp3gpp:EP_Common; } - grouping EP_NLSGrp { - uses eprp3gpp:EP_Common; - } - grouping EP_NL2Grp { uses eprp3gpp:EP_Common; } @@ -192,23 +192,123 @@ module _3gpp-5gc-nrm-ep { type string; } } - + grouping EP_NL1Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N60Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N41Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N42Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N89Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N11mbGrp { + uses eprp3gpp:EP_Common; + } + grouping EP_AIOT3Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N40Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N88Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N16mbGrp { + uses eprp3gpp:EP_Common; + } + grouping EP_N62Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N86Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N61Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL8Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL7Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL10Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N96Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_SM14Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N34Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N28Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N84Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL6Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL87Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N19mbGrp { + uses eprp3gpp:EP_Common; + } + grouping EP_N33Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N85Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_N63Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL5Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL9Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_NL3Grp { + uses eprp3gpp:EP_Common; + } + grouping EP_SM13Grp { + uses eprp3gpp:EP_Common; + } augment "/me3gpp:ManagedElement/af3gpp:AFFunction" { - list EP_N6 { - description "Represents the EP_N6 IOC."; + list EP_N5 { + description "Represents the EP_N5 IOC."; key id; uses top3gpp:Top_Grp; container attributes { - uses EP_N6Grp; + uses EP_N5Grp; } } - list EP_Rx { - description "Represents the EP_Rx IOC."; + list EP_N62 { + description "Represents the EP_N62 IOC."; key id; uses top3gpp:Top_Grp; container attributes { - uses EP_RxGrp; + uses EP_N62Grp; + } + } + list EP_N86 { + description "Represents the EP_N86 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N86Grp; } } } @@ -303,16 +403,14 @@ module _3gpp-5gc-nrm-ep { uses EP_N26Grp; } } - - list EP_NLS { - description "Represents the EP_NLS IOC."; + list EP_NL1 { + description "Represents the EP_NL1 IOC."; key id; uses top3gpp:Top_Grp; container attributes { - uses EP_NLSGrp; + uses EP_NL1Grp; } } - list EP_NL2 { description "Represents the EP_NL2 IOC."; key id; @@ -321,6 +419,56 @@ module _3gpp-5gc-nrm-ep { uses EP_NL2Grp; } } + + list EP_N60 { + description "Represents the EP_N60 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N60Grp; + } + } + list EP_N41 { + description "Represents the EP_N41 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N41Grp; + } + } + list EP_N42 { + description "Represents the EP_N42 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N42Grp; + } + } + list EP_N89 { + description "Represents the EP_N89 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N89Grp; + } + } + list EP_N11mb { + description "Represents the EP_N11mb IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N11mbGrp; + } + } + list EP_AIOT3 { + description "This IOC represents the AIOT3 interface between AMF and + AIOTF, which is defined in 3GPP TS 23.369."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_AIOT3Grp; + } + } } augment "/me3gpp:ManagedElement/ausf3gpp:AUSFFunction" { @@ -341,6 +489,14 @@ module _3gpp-5gc-nrm-ep { uses EP_N13Grp; } } + list EP_N61 { + description "Represents the EP_N61 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N61Grp; + } + } } augment "/me3gpp:ManagedElement/dn3gpp:DNFunction" { @@ -355,12 +511,36 @@ module _3gpp-5gc-nrm-ep { } augment "/me3gpp:ManagedElement/lmf3gpp:LMFFunction" { - list EP_NLS { - description "Represents the EP_NLS IOC."; + list EP_NL1 { + description "Represents the EP_NL1 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL1Grp; + } + } + list EP_NL8 { + description "Represents the EP_NL8 IOC."; key id; uses top3gpp:Top_Grp; container attributes { - uses EP_NLSGrp; + uses EP_NL8Grp; + } + } + list EP_NL7 { + description "Represents the EP_NL7 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL7Grp; + } + } + list EP_NL10 { + description "Represents the EP_NL10 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL10Grp; } } } @@ -405,7 +585,22 @@ module _3gpp-5gc-nrm-ep { uses EP_N26Grp; } } - + list EP_N96 { + description "Represents the EP_N96 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N96Grp; + } + } + list EP_SM14 { + description "Represents the EP_SM14 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_SM14Grp; + } + } } augment "/me3gpp:ManagedElement/nssf3gpp:NSSFFunction" { @@ -426,6 +621,14 @@ module _3gpp-5gc-nrm-ep { uses EP_N31Grp; } } + list EP_N34 { + description "Represents the EP_N34 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N34Grp; + } + } } augment "/me3gpp:ManagedElement/pcf3gpp:PCFFunction" { @@ -473,6 +676,22 @@ module _3gpp-5gc-nrm-ep { uses EP_RxGrp; } } + list EP_N28 { + description "Represents the EP_N28 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N28Grp; + } + } + list EP_N84 { + description "Represents the EP_N84 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N84Grp; + } + } } augment "/me3gpp:ManagedElement/sepp3gpp:SEPPFunction" { @@ -569,6 +788,30 @@ module _3gpp-5gc-nrm-ep { uses EP_S5CGrp; } } + list EP_N40 { + description "Represents the EP_N40 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N40Grp; + } + } + list EP_N88 { + description "Represents the EP_N88 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N88Grp; + } + } + list EP_N16mb { + description "Represents the EP_N16mb IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N16mbGrp; + } + } } augment "/me3gpp:ManagedElement/udm3gpp:UDMFunction" { @@ -598,6 +841,22 @@ module _3gpp-5gc-nrm-ep { uses EP_N13Grp; } } + list EP_NL6 { + description "Represents the EP_NL6 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL6Grp; + } + } + list EP_NL87 { + description "Represents the EP_NL87 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL87Grp; + } + } } @@ -646,5 +905,125 @@ module _3gpp-5gc-nrm-ep { uses EP_N6Grp; } } + list EP_N19mb { + description "Represents the EP_N19mb IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N19mbGrp; + } + } } + augment "/me3gpp:ManagedElement/nef3gpp:NEFFunction" { + list EP_N33 { + description "Represents the EP_N33 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N33Grp; + } + } + list EP_N85 { + description "Represents the EP_N85 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N85Grp; + } + } + list EP_N63 { + description "Represents the EP_N63 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N63Grp; + } + } + list EP_NL5 { + description "Represents the EP_NL5 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL5Grp; + } + } + } + augment "/me3gpp:ManagedElement/gmlc3gpp:GMLCFunction" { + list EP_NL9 { + description "Represents the EP_NL9 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL9Grp; + } + } + list EP_NL2 { + description "Represents the EP_NL2 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL2Grp; + } + } + list EP_NL3 { + description "Represents the EP_NL3 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL3Grp; + } + } + list EP_NL5 { + description "Represents the EP_NL5 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL5Grp; + } + } + list EP_NL6 { + description "Represents the EP_NL6 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL6Grp; + } + } + list EP_NL10 { + description "Represents the EP_NL10 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL10Grp; + } + } + } + augment "/me3gpp:ManagedElement/nwdaf3gpp:NWDAFFunction" { + list EP_NL9 { + description "Represents the EP_NL9 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_NL9Grp; + } + } + list EP_N34 { + description "Represents the EP_N34 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_N34Grp; + } + } + } + augment "/me3gpp:ManagedElement/scp3gpp:SCPFunction" { + list EP_SM13 { + description "Represents the EP_SM13 IOC."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses EP_SM13Grp; + } + } + } } \ No newline at end of file diff --git a/yang-models/_3gpp-5gc-nrm-managed-nfprofile.yang b/yang-models/_3gpp-5gc-nrm-managed-nfprofile.yang index 0cc653236d9d40cfbc7e12e789335525abde38d5..4f7e50dec37e0c38bbb21afb2f809d911b2790e1 100755 --- a/yang-models/_3gpp-5gc-nrm-managed-nfprofile.yang +++ b/yang-models/_3gpp-5gc-nrm-managed-nfprofile.yang @@ -12,11 +12,12 @@ module _3gpp-5gc-nrm-managed-nfprofile { organization "3gpp SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; -description "NF profile class. -Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, +description "NF profile dataType. +Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 29.510"; + revision 2026-03-25 { reference "CR-"; } revision 2026-01-25 { reference "CR-0060"; } // common for R19, R20 revision 2025-07-25 { reference CR-1558 ; } revision 2025-07-25 { reference "initial revision"; } @@ -54,220 +55,10 @@ TTA, TTC). All rights reserved."; type types3gpp:NfType; } } - grouping SupiRangeGrp { - leaf start { - description "First value identifying the start ofa SUPI range.To be - used when the range of SUPI's can be represented as a numeric range - (e.g., IMSI ranges)."; - type string { - pattern '^[0-9]+$'; - } - } - - leaf end { - description "Last value identifying the end of a SUPI range.To be - used when the range of SUPI's can be represented as a numeric range - (e.g. IMSI ranges)."; - type string { - pattern '^[0-9]+$'; - } - } - - leaf pattern { - description "Pattern representing the set of SUPI's belonging to - this range.A SUPI value is considered part of the range if and - only if the SUPI string fully matches the regular expression."; - type string; - } - } - - grouping ConditionItemGrp { - description "This data type represents a single condition item that - shall be evaluated to determine whether a discovered NF (Service) - Instance shall be selected."; - - leaf consumerNfTypes { - description "It represents the NF types of the consumers for - which the conditions included in this ConditionItem apply. - If this attribute is absent, the conditions are applicable - to all NF consumer types."; - type types3gpp:NfType; - } - leaf serviceFeature { - description "It represents a feature number of that NF Service - Instance,under CANARY_RELEASE status. This attribute only - applies when the selectionConditions, where this - ConditionItem is included, is included in a NF Service Instance - This condition is evaluated to when the service requests - froma consumer of this NF Service Instance require the support - of the indicated feature on the NF Service Instance."; - type uint32; // positive integer, 0 excluded by context - } - leaf vsServiceFeature { - description "It represents a Vendor-Specific feature - number of thatNF Service Instance, under CANARY_RELEASE - status. This attribute only applies when the - selectionConditions, where this ConditionItem is included, - is included in a NF Service Instance.This condition is - evaluated to true when the service requests from a - consumer of this NF Service Instance require the support - of the indicated Vendor-Specific feature on the NF - Service Instance."; - type uint32; - } - list supiRangeList { - description "It represents a set of SUPIs for which - the NF (Service) instance under CANARY_RELEASE status shall - be selected."; - key idx; - leaf idx { type uint32; } - uses SupiRangeGrp; - } - list gpsiRangeList { - description "It represents a set of GPSIs for which the NF - (Service) - instance under CANARY_RELEASE status shall be selected"; - min-elements 1; - key idx; - leaf idx { type uint32; } - uses IdentityRange; - } - list impuRangeList { - description "It represents a set of IMS Public Identities - for which the NF (Service) instance under CANARY_RELEASE - status shall be selected"; - min-elements 1; - key idx; - leaf idx { type uint32; } - uses IdentityRange; - } - list impiRangeList { - description "It represents a set of IMS Private Identities - for which theNF (Service) instance under - CANARY_RELEASE status shall be selected."; - min-elements 1; - key idx; - leaf idx { type uint32; } - uses IdentityRange; - } - leaf peiList { - description "It represents a set of PEIs of the UEs for - which the NF(Service) instance under CANARY_RELEASE status - shall be selected"; - type string; - } - list taiRangeList { - description "It represents a set of TAIs where the - NF(Service) instance under CANARY_RELEASE status shall - be selected for a certain UE"; - min-elements 1; - key idx; - leaf idx { type uint32; } - uses types5g3gpp:TaiRangeGrp; - } - leaf dnnList { - description " It represents a set of TAIs where the NF - (Service) instance under CANARY_RELEASE status shall be - selected for a certain UE"; - type string; - } - } - grouping PlmnSnssai { - list plmnId { - description "PLMN ID for which list of supported S-NSSAI(s) - is provided."; - min-elements 1; - max-elements 1; - key "mcc mnc"; - uses types3gpp:PLMNId; - } - list sNssaiList { - description "The specific list of S-NSSAIs supported - by the given PLMN."; - min-elements 1; - max-elements 1; - key "sst sd"; - uses types5g3gpp:SNssai; - } - leaf nid { - description "Network Identity; Shall be present if PlmnIdNid - identifies an SNPN "; - reference "see clauses 5.30.2.3, 5.30.2.9, 6.3.4, - and 6.3.8 in 3GPP TS 23.501 "; - type string; - } - } - - grouping ConditionGroupGrp { - description "This <> represents a group of conditions that - shall be evaluated to determine whether a discovered NF (Service) - Instanceshall be selected. (See clause 6.1.6.2.125 TS 29.510 [23])."; - - choice LogicalOperator{ - case and { - list and { - description "It represents a list of conditions where the - overall evaluation is true only if all the conditions - in the list are evaluated as true."; - key idx; - leaf idx { type uint32; } - uses SelectionConditionsGrp; - } - - } - case or{ - list or { - description "It represents a list of conditions where the - overall evaluation is true if at least one of the conditions - in the list evaluated as true"; - key idx; - leaf idx { type uint32; } - uses SelectionConditionsGrp; - } - } - } - - } - - grouping SelectionConditionsGrp { - description "This data type represents the list of conditions that - shall be selected by an NF Service Consumer."; - reference "(See clause 6.1.6.2.123 TS 29.510 [23])"; - - list conditionItem{ - key "id"; - description "It represent a single condition item that shall be - evaluated Instance shall be selected."; - leaf id{ - type string; - } - uses ConditionItemGrp; - } - - // circular dependency for grouping "ConditionGroupGrp" introduced in - //stage 2 - // container conditionGroup{ - // description "It represents a group of conditions - // that shall be evaluated"; - // uses ConditionGroupGrp; - // } - - } - - grouping IdentityRange { - leaf start { - description "First value identifying the start of an identity range. - To be used when the range of identities can be represented - as a numeric range (e.g., MSISDN ranges)."; - type string { - pattern '^[0-9]+$'; - } - } - leaf end {type string; } // dummy - leaf pattern {type string; } // dummy - } grouping ManagedNFProfileGrp { + description "Represents the ManagedNFProfile <> as defined in + clause 5.3.54 of 3GPP TS 28.541."; leaf nfInstanceId { description "String uniquely identifying a NF instance."; @@ -372,7 +163,7 @@ grouping ManagedNFProfileGrp { of the NFService(s)."; key idx; leaf idx { type uint32; } - uses PlmnSnssai; + uses nfs3gpp:PlmnSnssai; } list allowedSNPNs { @@ -406,12 +197,17 @@ grouping ManagedNFProfileGrp { uses types5g3gpp:SNssai; } - // list allowedRuleSet { - // description "S-NSSAI of the allowed slices to access the NF instance. - // If not provided, any slice is allowed to access the NF."; - // key "sst sd"; - // uses RuleSet;? -// } + list allowedRuleSet { + description "It represents map of rules specifying NF-Consumers + allowed or denied to access the NF-Producer. It may be present + when the NF-Producer and the NRF support Allowed-ruleset feature + as specified in clause 6.1.9."; + reference "3GPP TS 29.510"; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:RuleSetGrp; + } + leaf locality { description "Operator defined information about the location of the NF instance (e.g. geographic location, data center)."; @@ -438,6 +234,7 @@ grouping ManagedNFProfileGrp { description "Dynamic load information, ranged from 0 to 100, indicates the current load percentage of the NF."; type types3gpp:Load; + config false; } leaf loadTimeStamp { description "It indicates the point in time in which the latest load @@ -446,13 +243,15 @@ grouping ManagedNFProfileGrp { the NRF should set it to the instant when the NRF received the message where the NF provided the latest load information."; type yang:date-and-time ; + config false; } - leaf-list recoveryTime { + leaf recoveryTime { description "Timestamp when the NF was (re)started. The NRF shall notify NFs subscribed to receiving notifications of changes of the NF profile, if the NF recoveryTime is changed"; type yang:date-and-time; + config false; } leaf nfServicePersistence { description "This parameter indicates whether the different service @@ -463,6 +262,7 @@ grouping ManagedNFProfileGrp { Service Consumer "; reference "TS 29.510"; type boolean; + config false; } leaf-list nfSetIdList { type string ; @@ -486,17 +286,17 @@ grouping ManagedNFProfileGrp { max-elements 1; type boolean; } - leaf-list nfProfilePartialUpdateChangesSupportInd { + leaf nfProfilePartialUpdateChangesSupportInd { description "It represents NF Profile Partial Update Changes Support Indicator. TRUE: the NF Service Consumer supports receiving NF Profile Changes in the response to an NF Profile Partial Update operation. FALSE (default): the NF Service Consumer does not support receiving NF Profile Changes in the response to an NF Profile Partial Update operation"; - max-elements 1; type boolean; + config false; } - leaf-list nfProfileChangesInd { + leaf nfProfileChangesInd { description "NF Profile Changes Indicator. This IE shall be absent in the request to the NRF and may be included by the NRF in NFRegister or NFUpdate (NF Profile Complete Replacement) response. @@ -504,7 +304,7 @@ grouping ManagedNFProfileGrp { false (default): complete NF Profile."; type boolean; - max-elements 1; + config false; } list defaultNotificationSubscriptions { description "Notification endpoints for different notification types. @@ -513,6 +313,7 @@ grouping ManagedNFProfileGrp { as alternative notification endpoints."; key notificationType; min-elements 1; + config false; uses types3gpp:DefaultNotificationSubscription; } leaf servingScope { @@ -572,7 +373,7 @@ grouping ManagedNFProfileGrp { for inter-PLMN routing is specified."; type inet:domain-name; } - list nfServices { + list nfServiceList { description "List of NF Service Instances. It shall include the services produced by the NF that can be discovered by other NFs."; @@ -580,37 +381,17 @@ grouping ManagedNFProfileGrp { min-elements 1; uses nfs3gpp:NFServiceGrp; } - list supportedVendorSpecificFeatures { - description "It indicates a map of Vendor-Specific features, where the - key of the map is the IANA-assigned SMI Network Management Private - Enterprise Codes and the value of each entry of the map shall be - a list (array) of VendorSpecificFeature objects as defined - in the clause 5.3.247."; - key "enterpriseCode"; - - leaf enterpriseCode { - type uint32; - description "IANA-assigned SMI Network Management Private - Enterprise Code"; - } - - list vendorSpecificFeature { - key "featureName"; - config false; - description "VendorSpecificFeature objects as defined - in the clause 5.3.247."; - uses types5g3gpp:VendorSpecificFeatureGrp; - } - } + uses types5g3gpp:SupportedVendorSpecificFeaturesGrp; list selectionConditions { description "Identifications of Credentials Holder or Default Credentials Server. It is an array of FQDN."; leaf idx { type uint32; } key "idx"; - uses SelectionConditionsGrp; + max-elements 1; + uses nfs3gpp:SelectionConditionsGrp; } - leaf-list canaryRelease { + leaf canaryRelease { description "This attribute indicates whether an NF instance whose nfStatus is set to REGISTERED is in Canary Release condition, i.e. it should only be selected by NF Service Consumers under the @@ -619,10 +400,10 @@ grouping ManagedNFProfileGrp { nfStatus is set to REGISTERED False: the NF instance indicates its Canary Release condition via the nfStatus attribute"; - max-elements 1; type boolean; + default false; } - leaf-list exclusiveCanaryReleaseSelection { + leaf exclusiveCanaryReleaseSelection { description "This attribute indicates whether an NF Service Consumer should only select an NF Service Producer in Canary Release condition. @@ -630,8 +411,8 @@ grouping ManagedNFProfileGrp { condition False: the consumer may select producers not in Canary Release condition"; - max-elements 1; type boolean; + default false; } leaf sharedProfileDataId { description "This attribute indicates a string uniquely identifying @@ -643,16 +424,18 @@ grouping ManagedNFProfileGrp { Example: 4ace9d34-2c69-4f99-92d5-a73a3fe8e23b"; type string; } - leaf-list shutdownTime { + leaf shutdownTime { description "It indicates the timestamp when the NF Instance is planned to be shut down. This attribute may be present if the nfStatus is set to UNDISCOVERABLE due to scheduled shutdown"; type yang:date-and-time ; - max-elements 1; + config false; } - leaf supportedRcfs { + leaf-list supportedRcfs { description "It represents a list of Resource Content Filter IDs"; type string; + min-elements 1; + config false; } leaf canaryPrecedenceOverPreferred { description "ManagedNFProfile.canaryPrecedenceOverPreferred This @@ -671,6 +454,7 @@ grouping ManagedNFProfileGrp { in NF Service Producers shall not be prioritized over NF Service Consumer preferences at NF discovery requests)"; type boolean; + default false; } typedef NFStatus { type enumeration { diff --git a/yang-models/_3gpp-5gc-nrm-mbsmffunction.yang b/yang-models/_3gpp-5gc-nrm-mbsmffunction.yang new file mode 100644 index 0000000000000000000000000000000000000000..3dde496e8979b6623e841433a0f2c7842addeb0e --- /dev/null +++ b/yang-models/_3gpp-5gc-nrm-mbsmffunction.yang @@ -0,0 +1,277 @@ +module _3gpp-5gc-nrm-mbsmffunction { + yang-version 1.1; + namespace urn:3gpp:sa5:_3gpp-5gc-nrm-mbsmffunction; + prefix mbsmf3gpp; + + import _3gpp-common-managed-function { prefix mf3gpp; } + import _3gpp-common-managed-element { prefix me3gpp; } + import _3gpp-5g-common-yang-types { prefix types5g3gpp; } + import _3gpp-common-top { prefix top3gpp; } + import _3gpp-5gc-nrm-managed-nfprofile { prefix mnfp3gpp; } + import _3gpp-common-yang-types { prefix types3gpp; } + import _3gpp-5gc-nrm-neffunction { prefix nef3gpp; } + import ietf-inet-types { prefix inet; } + + organization "3gpp SA5"; + contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; + description "MNNPFFunction derived from basic ManagedFunction. + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + TTA, TTC). All rights reserved."; + reference "3GPP TS 28.541"; + + revision 2026-04-13 { reference CR-1694 ; } // common for rel-19,20 + + grouping TmgiRangeGrp { + description "This data type represents range of TMGIs. + (See clause 6.1.6.2.86 TS 29.510)."; + + leaf mbsServiceIdStart { + type string { + pattern "[A-Fa-f0-9]{6}"; + } + mandatory true; + description "Represents the first MBS Service ID value identifying the + start of a TMGI range. + The value shall be coded as defined for the mbsServiceId attribute of + the Tmgi data type defined in 3GPP TS 29.571"; + } + + leaf mbsServiceIdEnd { + type string { + pattern "[A-Fa-f0-9]{6}"; + } + mandatory true; + description "Represents the last MBS Service ID value identifying the + end of a TMGI range. + The value shall be coded as defined for the mbsServiceId attribute of + the Tmgi data type defined in 3GPP TS 29.571"; + } + + list pLMNId { + description "The PLMN identifier."; + key "mcc mnc"; + min-elements 1; + max-elements 1; + uses types3gpp:PLMNId; + } + + leaf nId { + type string; + mandatory true; + description "Network Identity; Shall be present if PlmnIdNid identifies + an SNPN (see clauses 5.30.2.3, 5.30.2.9, 6.3.4, and 6.3.8 in + 3GPP TS 23.501)"; + } + } + + grouping mbsSessionIdGrp { + description "The MBS session ID is used to identify a Multicast/Broadcast + MBS Session by the 5G system on external interface towards AF and between + AF and UE, and towards the UE."; + reference "3GPP TS 23.247 clause 6.5.1"; + + choice idType { + mandatory true; + leaf mbsServiceId { + description "MBS Service ID - Temporary Mobile Group Identity"; + type string { + pattern "[A-Fa-f0-9]{6}"; + } + } + case Ssm { + leaf sourceIpAddr { + type inet:ipv4-address; + mandatory true; + description "sourceIpAddr"; + } + leaf destIpAddr { + type inet:ipv4-address; + mandatory true; + description "destIpAddr"; + } + } + } + + leaf nid { + description ""; + type string { + pattern "[A-Fa-f0-9]{11}"; + } + } + } + + grouping MbsServiceAreaGrp { + description "This data type represents MBS Service Area Information for + Location dependent MBS session. (See clause 5.9.4.15 TS 29.571)."; + + list ncgiList { + description "Represents a list of NR cell ids with their pertaining TAIs."; + key idx; + leaf idx { type uint32 ; } + uses types5g3gpp:NcgiGrp; + } + + list taiList { + description "Tracking Area Identity list"; + key idx; + min-elements 1; + leaf idx { type uint32; } + uses types3gpp:TaiGrp; + } + } + + grouping MbsServiceAreaInfoGrp { + description "This data type represents MBS Service Area Information for + Location dependent MBS session. (See clause 5.9.4.15 TS 29.571"; + + leaf areaSessionId { + type uint16; + mandatory true; + description "This attribute represents Area Session Identifier used for + MBS session with location dependent content."; + } + + list mbsServiceArea { + description "Represents Area Session Identifier used for MBS session + with location dependent content."; + key idx; + leaf idx { type uint32 ; } + uses MbsServiceAreaGrp; + } + } + + grouping MbsSessionGrp { + description "This data type represents MBS Session served by an MB-SMF. + (See clause 6.1.6.2.87 TS 29.510)."; + + list mbsSessionId { + description "This attribute represents the MBS Session Identifier."; + min-elements 1; + max-elements 1; + key idx; + leaf idx { type uint32 ; } + uses mbsSessionIdGrp; + } + + list mbsAreaSessions { + description "This attribute represents map of Area Session Id and related + MBS Service Area information used for MBS session with location + dependent content. The Area Session ID together with the mbsSessionId + (TMGI) uniquely identifies the MBS session in a specific MBS service + area. + For an MBS session with location dependent content, one map entry shall + be registered for each MBS Service Area served by the MBS session. + The key of the map shall be the areaSessionId."; + key idx; + leaf idx { type uint32 ; } + uses MbsServiceAreaInfoGrp; + } + } + + grouping MbSmfInfoGrp { + description "This data type represents the specific data for the MB-SMF. + (See clause 6.1.6.2.85 TS 29.510)."; + + list sNssaiInfoList { + description "This attribute represents the list of S-NSSAIs and DNNs + supported by the MB-SMF. + The key of the map shall be a (unique) valid JSON string per clause 7 + of IETF RFC 8259, with a maximum of 32 characters."; + min-elements 1; + key idx; + leaf idx { type uint32 ; } + uses nef3gpp:SnssaiInfoItemGrp; + } + + list tmgiRangeList { + description "This attribute represents the list of TMGI range(s) + supported by the MB-SMF + The key of the map shall be a (unique) valid JSON string per clause 7 + of IETF RFC 8259, with a maximum of 32 characters."; + key idx; + leaf idx { type uint32 ; } + uses TmgiRangeGrp; + } + + list taiList { + description "This attribute represents the list of TAIs the MB-SMF can + serve. + The absence of this attribute and the taiRangeList attribute indicates + that the MB-SMF can be selected for any TAI in the serving network."; + key idx; + leaf idx { type uint32; } + uses types3gpp:TaiGrp; + } + + list taiRangeList { + description "This attribute represents the range of TAIs the MB-SMF can + serve. + The absence of this attribute and the taiList attribute indicates that + the MB-SMF can be selected for any TAI in the serving network."; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:TaiRangeGrp; + } + + list mbsSessionList { + description "This attribute represents the list of MBS sessions currently + served by the MB-SMF + The key of the map shall be a (unique) valid JSON string per clause 7 of + IETF RFC 8259, with a maximum of 32 characters."; + key idx; + leaf idx { type uint32; } + uses MbsSessionGrp; + } + } + + grouping MBSMFFunctionGrp { + description "Represents the SMFFuntion IOC"; + uses mf3gpp:ManagedFunctionGrp; + + list pLMNIdList { + description "List of PLMN IDs."; + key "mcc mnc"; + uses types3gpp:PLMNId; + } + + list managedNFProfile { + key idx; + leaf idx { type uint32; } + min-elements 1; + max-elements 1; + description "Profile definition of a Managed NF (See TS 23.501)"; + uses mnfp3gpp:ManagedNFProfileGrp; + } + + list commModelList { + min-elements 1; + key "groupId"; + description "Specifies a list of commModel. It can be used by NF and + NF services to interact with each other in 5G Core network "; + reference "3GPP TS 23.501"; + uses types5g3gpp:CommModel; + } + + list mbSmfInfo { + description "This attribute represents information of an + MB-SMF NF Instance"; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses MbSmfInfoGrp; + } + } + + augment "/me3gpp:ManagedElement" { + list MBSMFFunction { + description "This IOC represents the MB-SMF function defined in TS 23.501 + and TS 23.247."; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses MBSMFFunctionGrp; + } + uses mf3gpp:ManagedFunctionContainedClasses; + } + } +} \ No newline at end of file diff --git a/yang-models/_3gpp-5gc-nrm-mnpffunction.yang b/yang-models/_3gpp-5gc-nrm-mnpffunction.yang new file mode 100644 index 0000000000000000000000000000000000000000..5edb89fc1b104bcfd8fb0a37e00e1a20ce0e51b1 --- /dev/null +++ b/yang-models/_3gpp-5gc-nrm-mnpffunction.yang @@ -0,0 +1,84 @@ +module _3gpp-5gc-nrm-mnpffunction { + yang-version 1.1; + namespace urn:3gpp:sa5:_3gpp-5gc-nrm-mnpffunction; + prefix mnpf3gpp; + + import _3gpp-common-managed-function { prefix mf3gpp; } + import _3gpp-common-managed-element { prefix me3gpp; } + import _3gpp-5g-common-yang-types { prefix types5g3gpp; } + import _3gpp-common-top { prefix top3gpp; } + import _3gpp-5gc-nrm-managed-nfprofile { prefix mnfp3gpp; } + + organization "3gpp SA5"; + contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; + description "MNNPFFunction derived from basic ManagedFunction. + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + TTA, TTC). All rights reserved."; + reference "3GPP TS 28.541"; + + revision 2026-04-13 { reference CR-1694 ; } // common for rel-19,20 + + grouping MnpfInfoGrp { + description "Represents the data type MnpfInfo."; + + list msisdnRanges { + description "Represents the list of ranges of MSISDNs whose portability + status is available in the MNPF."; + min-elements 1; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:IdentityRangeGrp; + } + } + + grouping MNPFFunctionGrp { + description "Represents the SMFFuntion IOC"; + uses mf3gpp:ManagedFunctionGrp; + + list pLMNInfoList { + description "It defines the PLMN(s) of a Network Function."; + key "mcc mnc sd sst"; + min-elements 1; + uses types5g3gpp:PLMNInfo; + } + + list managedNFProfile { + key idx; + leaf idx { type uint32; } + min-elements 1; + max-elements 1; + description "Profile definition of a Managed NF (See TS 23.501)"; + uses mnfp3gpp:ManagedNFProfileGrp; + } + + list commModelList { + min-elements 1; + key "groupId"; + description "Specifies a list of commModel. It can be used by NF and + NF services to interact with each other in 5G Core network "; + reference "3GPP TS 23.501"; + uses types5g3gpp:CommModel; + } + + list mnpfInfo { + description "This attribute represents information of an MNPF NF + Instance"; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses MnpfInfoGrp; + } + } + + augment "/me3gpp:ManagedElement" { + list MNPFFunction { + description "MNPF NF"; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses MNPFFunctionGrp; + } + uses mf3gpp:ManagedFunctionContainedClasses; + } + } +} \ No newline at end of file diff --git a/yang-models/_3gpp-5gc-nrm-neffunction.yang b/yang-models/_3gpp-5gc-nrm-neffunction.yang index 6f8b80c808fa35400eb36ff932da668762934cb7..9c056d89db7da50b05d8ffcb1aed44bc1b9187e8 100755 --- a/yang-models/_3gpp-5gc-nrm-neffunction.yang +++ b/yang-models/_3gpp-5gc-nrm-neffunction.yang @@ -213,7 +213,7 @@ module _3gpp-5gc-nrm-neffunction { min-elements 1; key idx; leaf idx { type uint32 ; } - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list externalGroupIdentifiersRanges { @@ -222,7 +222,7 @@ module _3gpp-5gc-nrm-neffunction { min-elements 1; key idx; leaf idx { type uint32 ; } - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } leaf-list servedFqdnList { diff --git a/yang-models/_3gpp-5gc-nrm-nfservice.yang b/yang-models/_3gpp-5gc-nrm-nfservice.yang index 8ca29a704ee9d9fef7724c44f375fb4bf48f41d4..34176d07475eb09bf2bb683703efc0722c7ddebc 100755 --- a/yang-models/_3gpp-5gc-nrm-nfservice.yang +++ b/yang-models/_3gpp-5gc-nrm-nfservice.yang @@ -11,11 +11,12 @@ module _3gpp-5gc-nrm-nfservice { organization "3gpp SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; - description "NF service class. - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + description "NF service dataType. + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 29.510"; + revision 2026-01-25 { reference "C"; } // common for R19, R20 revision 2026-01-25 { reference "CR-0060"; } // common for R19, R20 revision 2025-01-25 { reference CR-1442; } revision 2023-09-18 { reference CR-1043 ; } @@ -24,7 +25,8 @@ module _3gpp-5gc-nrm-nfservice { revision 2019-06-17 { reference "initial revision"; } grouping NFServiceGrp { - description "Represents the NFService IOC"; + description "This data type represents the NF Service + defined in TS 29.510 [23]"; leaf serviceInstanceID { description "Unique ID of the service instance within a given NF Instance."; @@ -36,14 +38,16 @@ module _3gpp-5gc-nrm-nfservice { description "Name of the service instance (e.g. 'nudm-sdm')."; mandatory true; type ServiceName; + config false; } - list versions { //check in review if key is ok (unique) + list versions { description "API versions supported by the NF Service and if available, the corresponding retirement date of the NF Service."; min-elements 1; key "apiVersionInUri apiFullVersion"; uses NFServiceVersion; + config false; } leaf scheme { @@ -135,7 +139,7 @@ module _3gpp-5gc-nrm-nfservice { type string; } - list allowedNSSAI { + list allowedNSSAIs { description "S-NSSAI of the allowed slices to access the service instance. The absence of this attribute indicates that any slice is allowed to access the service instance."; @@ -144,6 +148,16 @@ module _3gpp-5gc-nrm-nfservice { key "sd sst"; uses types5g3gpp:SNssai; } + list allowedScopesRuleSet { + description "It represents map of rules specifying scopes allowed or + denied for NF-Consumers. This attribute may be present when the + NF-Producer and the NRF support Allowed-ruleset feature as specified + in clause 6.1.9 in TS 29.510."; + //optional support + key idx; + leaf idx { type uint32; } + uses types5g3gpp:RuleSetGrp; + } leaf-list allowedOperationsPerNfType { description "It indicates the allowed operations on resources for each type of NF; the key of the map is the NF Type, and the value @@ -168,18 +182,28 @@ module _3gpp-5gc-nrm-nfservice { for a given NF Instance ID take precedence over the scopes defined in attribute allowedOperationsPerNfType for the corresponding NF type of the NF Instance associated to such NF Instance ID.."; + //optional support } + list sNssais { + description "S-NSSAIs of the Network Function. If not + provided, the NF can serve any S-NSSAI. When present + this IE represents the list of S-NSSAIs supported in + all the PLMNs listed in the plmnList IE."; + //optional support + min-elements 1; + key "sst sd"; + uses types5g3gpp:SNssai; + } - leaf-list oauth2Required { + leaf oauth2Required { type boolean; - max-elements 1; + //optional support description "It indicates whether the NF Service Instance requires Oauth2-based authorization"; } - leaf-list sharedServiceDataId { + leaf sharedServiceDataId { type string; - max-elements 1; description "String uniquely identifying SharedServiceData. The format of the sharedServiceDataId shall be a Universally Unique Identifier (UUID) version 4, as described in IETF RFC 4122 [44]. The hexadecimal @@ -214,6 +238,129 @@ module _3gpp-5gc-nrm-nfservice { //optional support type string; } + list callbackUriPrefixList { + description "It indicates the optional path segment(s) used to construct + the prefix of the Callback URIs during the reselection of an NF + service consumer."; + //optional support + reference "3GPP TS 29.501 [23], clause 4.4.3."; + key callbackUriPrefix; + min-elements 1; + uses CallbackUriPrefixItemGrp; + } + leaf supportedFeatures { + description "It is a string, which indicates the features of the service + corresponding to the subscribed default notification, which are supported + by the NF (Service) instance acting as NF service consumer."; + reference "3GPP TS 29.571 table 5.2.2-3"; + //optional + type types3gpp:SupportedFeatures; + } + uses types5g3gpp:SupportedVendorSpecificFeaturesGrp; + leaf load { + description "Latest known load information of the NF, percentage."; + type types3gpp:Load; + config false; + } + leaf loadTimeStamp { + description "Timestamp of the reported load information."; + type yang:date-and-time; + config false; + } + leaf-list nfServiceSetIdList { + description "This attribute represents a list of NF Service Set ID. + At most one NF Service Set ID shall be indicated per PLMN-ID or + SNPN of the NF."; + type string; + min-elements 1; + } + list perPlmnSnssaiList { + description "It includes the S-NSSAIs supported by the Network Function + for each PLMN supported by the Network Function. When present, it + shall override sNssais IE."; + key idx; + leaf idx { type uint32; } + uses PlmnSnssai; + } + + leaf canaryRelease { + description "This attribute indicates whether an NF instance whose + nfStatus is set to REGISTERED is in Canary Release condition, i.e. + it should only be selected by NF Service Consumers under the + conditions indicated by the selectionConditions attribute. + True: the NF is under Canary Release condition, even if the + nfStatus is set to REGISTERED. + False: the NF instance indicates its Canary Release condition + via the nfStatus attribute."; + //optional support + type boolean; + default false; + } + + leaf exclusiveCanaryReleaseSelection { + description "This attribute indicates whether an NF Service Consumer + should only select an NF Service Producer in Canary Release condition. + True: the consumer shall only select producers in Canary Release + condition. + False: the consumer may select producers not in Canary Release + condition."; + //optional support + type boolean; + default false; + } + + leaf shutdownTime { + description "This attribute may be present if the nfStatus is set to + UNDISCOVERABLE due to scheduled shutdown. When present, it shall + indicate the timestamp when the NF Instance is planned to be + shut down."; + //optional support + type yang:date-and-time; + config false; + } + + leaf canaryPrecedenceOverPreferred { + description "This attribute indicates whether the NRF shall prioritize + the NF Service Producer in Canary Release condition over the + preferences (preferred-xxx, ext-preferred-xxx) present in NF + discovery requests. + True: NRF shall prioritize NF Service Producers in Canary Release + condition at NF discovery requests. + False: NRF shall prioritize the NF Service Producers according to + preferred-xxx and/or ext-preferred-xxx."; + //optional support + type boolean; + default false; + } + + list perPlmnOauth2ReqList { + description "This attribute includes the Oauth2-based authorization + requirement supported by the NF Service Instance per PLMN of the + NF Service Consumer. This attribute may be included when the + Oauth2.0 authorization requirement supported by the NF Service + Instance for different PLMN is different. When the requester + PLMN Id is available in perPlmnOauth2ReqList IE, this IE shall + override the oauth2Required IE. If the requester PLMN ID is not + present in perPlmnOauth2ReqList IE, then the value of + oauth2Required IE shall be applicable if available."; + //optional support + key idx; + leaf idx { type uint32; } + max-elements 1; + uses PlmnOauth2Grp; + } + + list selectionConditions { + description "This attribute includes the conditions under which an NF + Instance with an NFStatus value set to CANARY_RELEASE, or with a + canaryRelease attribute set to true, shall be selected by an NF + Service Consumer."; + //optional support + key idx; + leaf idx { type uint32; } + max-elements 1; + uses SelectionConditionsGrp; + } } typedef SupportedFeatures { @@ -242,7 +389,219 @@ module _3gpp-5gc-nrm-nfservice { in the clause 5.3.247."; uses types5g3gpp:VendorSpecificFeatureGrp; } - } + } + + grouping CallbackUriPrefixItemGrp { + description "This <> represents Callback URI prefix value to + be used for specific notification types."; + reference "3GPP TS 29.510 clause 6.1.6.2.127"; + + leaf callbackUriPrefix { + description "It indicates the optional path segment(s) used to + construct the prefix of the Callback URIs during the reselection + of an NF service consumer."; + mandatory true; + type inet:uri; + reference "3GPP TS 29.501 clause 4.4.3"; + } + + leaf-list notificationTypes { + description "List of notification type values using the callback + URI prefix of the callbackUriPrefix."; + type string; + } + } + + grouping PlmnOauth2Grp { + description "This <> represents the per PLMN Oauth2.0 + indication."; + reference "3GPP TS 29.510 clause 6.1.6.2.102"; + + list oauth2RequiredPlmnIdList { + description "List of PLMN IDs for which Oauth2.0 authorization is + required."; + //optional support + min-elements 1; + key "mcc mnc"; + uses types3gpp:PLMNId; + } + + list oauth2NotRequiredPlmnIdList { + description "List of PLMN IDs for which Oauth2.0 authorization is + not required."; + //optional support + min-elements 1; + key "mcc mnc"; + uses types3gpp:PLMNId; + } + } + + grouping PlmnSnssai { + description "This data type represents the list of S-NSSAIs supported + per PLMN."; + list plmnId { + description "PLMN ID for which list of supported S-NSSAI(s) + is provided."; + min-elements 1; + max-elements 1; + key "mcc mnc"; + uses types3gpp:PLMNId; + } + list sNssaiList { + description "The specific list of S-NSSAIs supported + by the given PLMN."; + min-elements 1; + max-elements 1; + key "sst sd"; + uses types5g3gpp:SNssai; + } + leaf nid { + description "Network Identity; Shall be present if PlmnIdNid + identifies an SNPN."; + reference "see clauses 5.30.2.3, 5.30.2.9, 6.3.4, + and 6.3.8 in 3GPP TS 23.501"; + type string; + } + } + + grouping ConditionItemGrp { + description "This <> represents a single condition item that + shall be evaluated to determine whether a discovered NF (Service) + Instance shall be selected."; + reference "3GPP TS 29.510 clause 6.1.6.2.124"; + + leaf-list consumerNfTypes { + description "It represents the NF types of the consumers for which + the conditions included in this ConditionItem apply. If this + attribute is absent, the conditions are applicable to all NF + consumer types."; + min-elements 1; + type types3gpp:NfType; + } + leaf serviceFeature { + description "It represents a feature number of that NF Service + Instance, under CANARY_RELEASE status."; + type uint32; + } + leaf vsServiceFeature { + description "It represents a Vendor-Specific feature number of that + NF Service Instance, under CANARY_RELEASE status."; + type uint32; + } + list supiRangeList { + description "It represents a set of SUPIs for which the NF (Service) + instance under CANARY_RELEASE status shall be selected."; + key idx; + leaf idx { type uint32; } + min-elements 1; + uses types5g3gpp:SupiRangeGrp; + } + list gpsiRangeList { + description "It represents a set of GPSIs for which the NF (Service) + instance under CANARY_RELEASE status shall be selected."; + key idx; + leaf idx { type uint32; } + min-elements 1; + uses types5g3gpp:IdentityRangeGrp; + } + list impuRangeList { + description "It represents a set of IMS Public Identities for which + the NF (Service) instance under CANARY_RELEASE status shall be + selected."; + key idx; + leaf idx { type uint32; } + min-elements 1; + uses types5g3gpp:IdentityRangeGrp; + } + list impiRangeList { + description "It represents a set of IMS Private Identities for which + the NF (Service) instance under CANARY_RELEASE status shall be + selected."; + key idx; + leaf idx { type uint32; } + min-elements 1; + uses types5g3gpp:IdentityRangeGrp; + } + leaf-list peiList { + description "It represents a set of PEIs of the UEs for which the + NF (Service) instance under CANARY_RELEASE status shall be + selected."; + min-elements 1; + type string; + } + list taiRangeList { + description "It represents a set of TAIs where the NF (Service) + instance under CANARY_RELEASE status shall be selected for a + certain UE."; + key idx; + leaf idx { type uint32; } + min-elements 1; + uses types5g3gpp:TaiRangeGrp; + } + leaf-list dnnList { + description "It represents a set of DNNs where the NF (Service) + instance under CANARY_RELEASE status shall be selected."; + min-elements 1; + type string; + } + } + + grouping SelectionConditionsGrp { + description "This <> represents the list of conditions that + shall be selected by an NF Service Consumer."; + reference "3GPP TS 29.510 clause 6.1.6.2.123"; + + list conditionItem { + key "id"; + description "It represent a single condition item that shall be + evaluated to determine whether a discovered NF (Service) Instance + shall be selected."; + leaf id { type string; } + uses ConditionItemGrp; + } + + list conditionGroup { + description "It represents a group of conditions that shall be + evaluated."; + key idx; + leaf idx { type uint32; } + max-elements 1; + // Note: ConditionGroup references SelectionConditions creating a + // circular dependency. Inlined one level to avoid it. + choice LogicalOperator { + case and { + list and { + description "It represents a list of conditions where the + overall evaluation is true only if all the conditions in + the list are evaluated as true."; + key idx; + leaf idx { type uint32; } + list conditionItem { + key "id"; + description "Condition item to be evaluated."; + leaf id { type string; } + uses ConditionItemGrp; + } + } + } + case or { + list or { + description "It represents a list of conditions where the + overall evaluation is true if at least one of the conditions + in the list is evaluated as true."; + key idx; + leaf idx { type uint32; } + list conditionItem { + key "id"; + description "Condition item to be evaluated."; + leaf id { type string; } + uses ConditionItemGrp; + } + } + } + } + } + } grouping ipEndPoint { choice address { leaf ipv4Address { diff --git a/yang-models/_3gpp-5gc-nrm-nrffunction.yang b/yang-models/_3gpp-5gc-nrm-nrffunction.yang index a982a6d966bdbaca0f4694d362f45afff6790357..7893a8a952614e049f3bc26cebb0b78a724c6aaf 100755 --- a/yang-models/_3gpp-5gc-nrm-nrffunction.yang +++ b/yang-models/_3gpp-5gc-nrm-nrffunction.yang @@ -23,6 +23,7 @@ module _3gpp-5gc-nrm-nrffunction { import _3gpp-5gc-nrm-gmlcfunction { prefix gmlc3gpp;} import _3gpp-5gc-nrm-lmffunction { prefix lmf3gpp;} import _3gpp-5gc-nrm-aiot { prefix aiot3gpp;} + import _3gpp-5gc-nrm-chffunction { prefix chf3gpp;} organization "3gpp SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; @@ -72,47 +73,6 @@ module _3gpp-5gc-nrm-nrffunction { uses types3gpp:Ipv6PrefixRange; } } - grouping chfInfo { - list supiRangeList { - description "List of ranges of SUPIs that can be served by - the CHF instance. If not provided, the CHF can serve any SUPI."; - key "start end pattern"; - min-elements 1; - uses mnfp3gpp:SupiRangeGrp; - } - - list gpsiRangeList { - description "List of ranges of GPSI that can be served - by the CHF instance. If not provided, the CHF can serve any GPSI."; - key idx; - leaf idx { type uint32; } - min-elements 1; - uses mnfp3gpp:IdentityRange; - } - - list plmnRangeList { - description "List of ranges of PLMNs (including the PLMN - IDs of the CHF instance) that can be served by the CHF instance. - If not provided, the CHF can serve any PLMN."; - - min-elements 1; - key "mcc mnc"; - uses types3gpp:PLMNId; - } - leaf primaryChfInstance { - description "This attribute represents the NF Instance Id of the - primary CHF instance. This attribute shall be absent if the - secondaryChfInstance is present."; - type string; - - } - leaf secondaryChfInstance { - description "This attribute represents the NF Instance Id of the - secondary CHF instance.This attribute shall be absent if the - primaryChfInstance is present."; - type string; - } - } grouping pcscfInfo { description "This data type represents the information of a P-CSCF NF Instance. @@ -212,7 +172,7 @@ module _3gpp-5gc-nrm-nrffunction { description "Unique identifier for the IMSI range."; type string; } - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list imsPublicIdentityRanges{ description "This attribute defines the list of ranges of MSISDNs whose @@ -223,7 +183,7 @@ module _3gpp-5gc-nrm-nrffunction { description "Unique identifier for the IMSI range."; type string; } - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list msisdnRanges{ description "This attribute defines the list of ranges of IMS Public @@ -234,7 +194,7 @@ module _3gpp-5gc-nrm-nrffunction { description "Unique identifier for the IMSI range."; type string; } - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list externalGroupIdentifiersRanges{ description "This attribute defines the list of ranges of external @@ -246,7 +206,7 @@ module _3gpp-5gc-nrm-nrffunction { description "Unique identifier for the IMSI range."; type string; } - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list hssDiameterAddress{ description "This attribute defines the Diameter Address of the HSS "; @@ -413,7 +373,7 @@ module _3gpp-5gc-nrm-nrffunction { } min-elements 1; - uses chfInfo; + uses chf3gpp:ChfInfoGrp; } list servedNwdafInfo { diff --git a/yang-models/_3gpp-5gc-nrm-nsacffunction.yang b/yang-models/_3gpp-5gc-nrm-nsacffunction.yang new file mode 100755 index 0000000000000000000000000000000000000000..f35dfb0a37b28f99c22f88b24f8cb44d41389fe4 --- /dev/null +++ b/yang-models/_3gpp-5gc-nrm-nsacffunction.yang @@ -0,0 +1,276 @@ +module _3gpp-5gc-nrm-nsacffunction { + yang-version 1.1; + + namespace urn:3gpp:sa5:_3gpp-5gc-nrm-nsacffunction; + prefix nsacf3gpp; + + import _3gpp-common-managed-function { prefix mf3gpp; } + import _3gpp-common-managed-element { prefix me3gpp; } + import ietf-inet-types { prefix inet; } + import _3gpp-common-yang-types { prefix types3gpp; } + import _3gpp-5g-common-yang-types { prefix types5g3gpp; } + import _3gpp-common-top { prefix top3gpp; } + import _3gpp-5gc-nrm-managed-nfprofile { prefix mnfp3gpp; } + + organization "3gpp SA5"; + contact + "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; + description "This IOC represents the NSACF function in 5GC. + The NSACF monitors and controls the number of registered + UEs per network slice for the network slices that are + subject to Network Slice Admission Control (NSAC). + For more information about the NSACF, see TS 23.501 + and TS 23.502. + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, + CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; + reference "3GPP TS 28.541"; + + revision 2026-03-25 { reference "CR-"; } + + grouping NsacfCapabilityGrp { + description "This data type represents the NSACF service + capability. (See TS 29.510)."; + reference "3GPP TS 29.510"; + + leaf supportUeSAC { + type boolean; + description "This attribute indicates the service capability of the + NSACF to monitor and control the number of + registered UEs per network slice for the network + slice that is subject to NSAC."; + } + + leaf supportPduSAC { + type boolean; + description "This attribute indicates the service capability of the + NSACF to monitor and control the number of + established PDU sessions per network slice for the + network slice that is subject to NSAC."; + } + } + + grouping NsacfInfoGrp { + description "This data type represents the information + of an NSACF NF Instance. (see TS 29.510)."; + reference "3GPP TS 29.510"; + + list nsacfCapability { + description "It represents the NSACF service + capability."; + min-elements 1; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses NsacfCapabilityGrp; + } + + list taiList { + description "List of TAIs."; + key idx; + leaf idx { type uint32; } + uses types3gpp:TaiGrp; + } + + list taiRangeList { + description "Range of TAIs."; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:TaiRangeGrp; + } + } + + grouping SnssaiInfoGrp { + description "This data type defines generic information + for a S-NSSAI."; + + list pLMNInfo { + description "It represents the PLMN and S-NSSAI + information."; + min-elements 1; + max-elements 1; + key "mcc mnc sd sst"; + uses types5g3gpp:PLMNInfo; + } + + leaf administrativeState { + type types3gpp:BasicAdministrativeState; + mandatory true; + description "It represents the administrative state + of the Network Slice."; + } + } + + grouping NsacfInfoSnssaiGrp { + description "This data type defines NSACF specific + information per S-NSSAI."; + + list snssaiInfo { + description "It defines generic information for a + S-NSSAI. The information includes global unique + identifier of a Network Slice and + administrativeState of the Network Slice."; + min-elements 1; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses SnssaiInfoGrp; + } + + leaf isSubjectToNsac { + type boolean; + mandatory true; + description "It defines if the Network Slice subjects + to network slice admission control. The value is + set to False if the maxNumberofUEs attribute in + corresponding SliceProfile is absent."; + } + + leaf maxNumberofUEs { + type uint16 { + range "0..65535"; + } + mandatory true; + description "It defines the maximum number of UEs + which are allowed to be served by the Network + Slice that is subject to network slice admission + control."; + } + + leaf eACMode { + type enumeration { + enum ACTIVE; + enum INACTIVE; + } + default INACTIVE; + description "It represents if early admission + control (EAC) mode is activated."; + } + + leaf activeEacThreshold { + type uint8 { + range "0..100"; + } + default 0; + description "It defines threshold in percentage + value of the number of the UEs registered with + the network slice to the maximum number of UEs + allowed to register with the network slice. The + eACMode is set to active when the number of the + UEs registered with the network slice is above + this threshold."; + } + + leaf deactiveEacThreshold { + type uint8 { + range "0..100"; + } + default 100; + description "It defines threshold in percentage + value of the number of the UEs registered with + the network slice to the maximum number of UEs + allowed to register with the network slice. The + eACMode is set to inactive when the number of + the UEs registered with the network slice is + below this threshold. If this attribute is + absent, activeEacThreshold is used to trigger + deactivation of eACMode."; + } + + leaf numberofUEs { + type uint16 { + range "0..65535"; + } + config false; + description "It represents the number of the UEs + registered with the network slice. This attribute + is updated by NSACF."; + } + + leaf-list uEIdList { + type string; + config false; + description "It represents the UEs registered with + the network slice. This attribute is updated by + NSACF."; + } + + list taiList { + description "Tracking Area Identity list."; + key idx; + leaf idx { type uint32; } + uses types3gpp:TaiGrp; + } + + leaf maxNumberofPDUSessions { + type uint32; + mandatory true; + description "It defines the maximum number of + concurrent PDU sessions supported by the network + slice."; + } + } + + grouping NSACFFunctionGrp { + description "Represents the NSACFFunction IOC."; + uses mf3gpp:ManagedFunctionGrp; + + list pLMNInfoList { + description "List of at most six entries of PLMN + Identifiers, but at least one (the primary + PLMN Id). The PLMN Identifier is composed of a + Mobile Country Code (MCC) and a Mobile Network + Code (MNC)."; + min-elements 1; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:PLMNInfo; + } + + leaf sBIFQDN { + description "The FQDN of the registered NF instance + in the service-based interface."; + type inet:domain-name; + } + + list managedNFProfile { + description "This data type represents a Profile + definition of a Managed NF."; + key idx; + leaf idx { type uint32; } + min-elements 1; + max-elements 1; + uses mnfp3gpp:ManagedNFProfileGrp; + } + + list nsacfInfoSnssaiList { + description "It represents a list of NSACF + information per SNSSAI."; + key idx; + leaf idx { type uint32; } + uses NsacfInfoSnssaiGrp; + } + + list nsacfInfo { + description "This attribute represents the + information of an NSACF NF Instance. + (see TS 29.510)."; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses NsacfInfoGrp; + } + } + + augment "/me3gpp:ManagedElement" { + list NSACFFunction { + description "5G Core NSACF Function"; + reference "3GPP TS 28.541"; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses NSACFFunctionGrp; + } + uses mf3gpp:ManagedFunctionContainedClasses; + } + } +} diff --git a/yang-models/_3gpp-5gc-nrm-nssaaffunction.yang b/yang-models/_3gpp-5gc-nrm-nssaaffunction.yang new file mode 100755 index 0000000000000000000000000000000000000000..5498f632f74f82374c1fa69b24ccf594194cf1ea --- /dev/null +++ b/yang-models/_3gpp-5gc-nrm-nssaaffunction.yang @@ -0,0 +1,119 @@ +module _3gpp-5gc-nrm-nssaaffunction { + yang-version 1.1; + namespace urn:3gpp:sa5:_3gpp-5gc-nrm-nssaaffunction; + prefix nssaaf3gpp; + + import _3gpp-common-managed-function { prefix mf3gpp; } + import _3gpp-common-managed-element { prefix me3gpp; } + import _3gpp-5g-common-yang-types { prefix types5g3gpp; } + import _3gpp-common-top { prefix top3gpp; } + import _3gpp-5gc-nrm-managed-nfprofile { prefix mnfp3gpp; } + import ietf-inet-types { prefix inet; } + + organization "3gpp SA5"; + contact + "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; + description "This IOC represents the NSSAAF function in 5GC. + For more information about the NSSAAF, see TS 23.501. + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, + CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; + reference "3GPP TS 28.541"; + + revision 2026-03-25 { reference "CR-"; } + + grouping NssaafInfoGrp { + description "This data type represents the information + of a NSSAAF NF Instance. + (See clause 6.1.6.2.104 TS 29.510)."; + + list supiRanges { + description "List of ranges of SUPIs that can be + served by the NSSAAF instance."; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:SupiRangeGrp; + } + + list internalGroupIdentifiersRanges { + description "List of ranges of Internal Group + Identifiers that can be served by the NSSAAF + instance. If not provided, it does not imply + that the NSSAAF supports all internal groups."; + key idx; + leaf idx { type uint32; } + uses types5g3gpp:InternalGroupIdRangeGrp; + } + } + + grouping NSSAAFFunctionGrp { + description "Represents the NSSAAFFunction IOC."; + uses mf3gpp:ManagedFunctionGrp; + + list pLMNInfoList { + description "It defines the PLMN(s) of a Network + Function."; + key "mcc mnc sd sst"; + min-elements 1; + uses types5g3gpp:PLMNInfo; + } + + leaf sBIFQDN { + description "The FQDN of the registered NF instance + in the service-based interface."; + type inet:domain-name; + } + + leaf-list cNSIIdList { + description "NSI ID. NSI ID is an identifier for + identifying the Core Network part of a Network + Slice instance when multiple Network Slice + instances of the same Network Slice are deployed, + and there is a need to differentiate between them + in the 5GC, see clause 3.1 of TS 23.501 and + subclause 6.1.6.2.7 of 3GPP TS 29.531."; + type string; + } + + list managedNFProfile { + key idx; + leaf idx { type uint32; } + min-elements 1; + max-elements 1; + description "Profile definition of a Managed NF + (See TS 23.501)."; + uses mnfp3gpp:ManagedNFProfileGrp; + } + + list commModelList { + min-elements 1; + key "groupId"; + description "Specifies a list of commModel. It can + be used by NF and NF services to interact with + each other in 5G Core network."; + reference "3GPP TS 23.501"; + uses types5g3gpp:CommModel; + } + + list nssaafInfo { + description "This attribute represents information + of a NSSAAF NF Instance."; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses NssaafInfoGrp; + } + } + + augment "/me3gpp:ManagedElement" { + list NSSAAFFunction { + description "5G Core NSSAAF Function"; + reference "3GPP TS 28.541"; + key id; + uses top3gpp:Top_Grp; + container attributes { + uses NSSAAFFunctionGrp; + } + uses mf3gpp:ManagedFunctionContainedClasses; + } + } +} diff --git a/yang-models/_3gpp-5gc-nrm-pcffunction.yang b/yang-models/_3gpp-5gc-nrm-pcffunction.yang index a9ab6b43533518c90033bb0824679bfdffb8d317..bc37675543a63a972b2b287b8eac32ff56ad49f2 100755 --- a/yang-models/_3gpp-5gc-nrm-pcffunction.yang +++ b/yang-models/_3gpp-5gc-nrm-pcffunction.yang @@ -116,7 +116,7 @@ module _3gpp-5gc-nrm-pcffunction { key idx; leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:SupiRangeGrp; + uses types5g3gpp:SupiRangeGrp; } leaf rxDiamHost { diff --git a/yang-models/_3gpp-5gc-nrm-predefinedpccruleset.yang b/yang-models/_3gpp-5gc-nrm-predefinedpccruleset.yang index c54cbddb7a9f31b3702a899aff885f60fd885b5d..274eaad1523c44b76fde5213ab9d600728e008d4 100755 --- a/yang-models/_3gpp-5gc-nrm-predefinedpccruleset.yang +++ b/yang-models/_3gpp-5gc-nrm-predefinedpccruleset.yang @@ -6,18 +6,21 @@ module _3gpp-5gc-nrm-predefinedpccruleset { import _3gpp-common-managed-element { prefix me3gpp; } import _3gpp-common-top { prefix top3gpp; } + import _3gpp-5g-common-yang-types { prefix types5g3gpp; } import _3gpp-5gc-nrm-smffunction { prefix smf3gpp; } import _3gpp-5gc-nrm-pcffunction { prefix pcf3gpp; } import ietf-yang-types { prefix yang; } + import ietf-inet-types { prefix inet; } organization "3gpp SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; description "This IOC represents the predefined PCC rules, which are configured to SMF and referenced by PCF. - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.541"; + revision 2026-03-20 { reference CR-1695 ; } revision 2025-05-01 { reference CR-xxxx ; } revision 2025-04-25 { reference CR-1520 ; } revision 2025-03-25 { reference CR-1489 ; } @@ -32,8 +35,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { reference " 3GPP TS 29.512"; leaf periodicity { type uint32; - description "It identifies the time period between the start of two bursts - in reference to the TSN GM."; + description "It identifies the time period between the start of two + bursts in reference to the TSN GM."; reference "3GPP TS 29.571."; } leaf burstArrivalTime { @@ -45,7 +48,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } grouping ConditionData { - description "It specifies the specifies the condition data for a PCC rule."; + description "It specifies the specifies the condition data for a + PCC rule."; leaf condId { type string; mandatory true; @@ -53,14 +57,14 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } leaf activationTime { type yang:date-and-time; - description " It indicates the time (in date-time format) when the decision - data shall be activated."; + description " It indicates the time (in date-time format) when the + decision data shall be activated."; reference "3GPP29.512 and TS 29.571."; } leaf deactivationTime { type yang:date-and-time; - description "It indicates the time (in date-time format) when the decision - data shall be deactivated."; + description "It indicates the time (in date-time format) when the + decision data shall be deactivated."; reference "3GPPTS 29.512 and TS 29.571."; } leaf accessType { @@ -104,9 +108,11 @@ module _3gpp-5gc-nrm-predefinedpccruleset { enum LOAD_BALANCING; enum SMALLEST_DELAY; enum PRIORITY_BASED; + enum REDUNDANT; } mandatory true; - description "It indicates the value of the steering mode, see TS 29.512."; + description "It indicates the value of the steering mode"; + reference " see TS 29.512."; } leaf active { type enumeration { @@ -152,8 +158,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { leaf notifCorreId { type string; mandatory true; - description "It is used to set the value of Notification Correlation ID in - the notification sent by the SMF, see TS 29.512"; + description "It is used to set the value of Notification Correlation ID + in the notification sent by the SMF, see TS 29.512"; } leaf dnaiChgType { type enumeration { @@ -237,7 +243,23 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } } - grouping TrafficControlDataInformation { + grouping OnPathN6SigInfoGrp { + description "Represents the data type OnPathN6SigInfo"; + leaf onPathN6Method { + type enumeration { + enum CONNECT_UDP; + } + default CONNECT_UDP; + description "It indicates the supported on-path N6 signaling method."; + } + leaf asProxyAddr { + type inet:ip-address; + mandatory true; + description "It represents the AF Server proxy address."; + } + } + + grouping TrafficControlDataGrp { description "It specifies the traffic control data for a service flow of a PCC rule."; leaf tcId { @@ -266,8 +288,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } container addRedirectInfo { description "It contains the additional redirect information indicating - whether the detected application traffic should be redirected to another - controlled address."; + whether the detected application traffic should be redirected to another + controlled address."; list redirectInfo { description "The list of redirect information indicating whether the detected application traffic should be redirected to another @@ -279,18 +301,19 @@ module _3gpp-5gc-nrm-predefinedpccruleset { leaf muteNotif { type boolean; default false; - description "It indicates whether applicat'on's start or stop notification - is to be muted."; + description "It indicates whether applicat'on's start or stop + notification is to be muted."; } leaf trafficSteeringPolIdDl { type string; - description "It references to a pre-configured traffic steering policy for downlink traffic at the SMF, see TS 29.512"; + description "It references to a pre-configured traffic steering policy + for downlink traffic at the SMF, see TS 29.512"; } leaf trafficSteeringPolIdUl { type string; - description "It references to a pre-configured traffic steering policy for - uplink traffic at the SMF, see TS 29.512"; - } + description "It references to a pre-configured traffic steering policy + for uplink traffic at the SMF, see TS 29.512"; + } container routeToLocs { description "It provides a list of location which the traffic shall be routed to for the AF request."; @@ -301,13 +324,22 @@ module _3gpp-5gc-nrm-predefinedpccruleset { uses RouteToLocation; } } + leaf traffCorreInd { + type boolean; + default false; + description "It indicates the traffic correlation."; + } uses UpPathChgEvent; leaf steerFun { type enumeration { enum MPTCP; enum ATSSS_LL; + enum MPQUIC_UDP; + enum MPQUIC_IP; + enum MPQUIC_E; } - description "It indicates the applicable traffic steering functionality."; + description "It indicates the applicable traffic steering + functionality."; reference "3GPPTS 29.512"; } container steerModeDl { @@ -316,7 +348,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { uses SteeringMode; } container steerModeUl { - description "It provides the traffic distribution rule across 3GPP and Non-3GPP accesses to apply for uplink traffic."; + description "It provides the traffic distribution rule across 3GPP and + Non-3GPP accesses to apply for uplink traffic."; uses SteeringMode; } leaf mulAccCtrl { @@ -324,12 +357,140 @@ module _3gpp-5gc-nrm-predefinedpccruleset { enum ALLOWED; enum NOT_ALLOWED; } - description "It indicates whether the service data flow, corresponding to the service data flow template, is allowed or not allowed."; + description "It indicates whether the service data flow, corresponding to + the service data flow template, is allowed or not allowed."; + } + list sNSSAIList { + description "It represents the list of S-NSSAI the managed object is + supporting. The S-NSSAI is defined in 3GPP TS 23.003."; + key idx; + leaf idx { type uint32 ; } + uses types5g3gpp:SNssai; + } + leaf l4sInd { + type enumeration { + enum UL; + enum DL; + enum UL_DL; + } + description "It represents an explicit indication of whether ECN marking + for L4S enabled for the UL, the DL or both UL and DL. + + When SMF receives it in the PCC rule, SMF may decide to enable for the + QoS flow the ECN marking for L4S in either the 5G-AN or in the PSA UPF + see clause 4.2.6.2.21 in TS 29.512)."; + } + list onPathN6SigInfo { + max-elements 1; + key idx; + leaf idx { type uint32; } + description "On-path N6 signalling methods are used to transfer media + related information over N6 where media related information is sent + together with the encrypted payload allowing media related information + to be received synchronously with the media packet, see the + clause 4.2.6.10.8 in TS 29.512. + + This attribute represents the on-path N6 signaling information for + delivering media related information."; + uses OnPathN6SigInfoGrp; + + } + leaf dataBurstSizeInd { + type boolean; + default false; + description "It indicates the Data Burst Size marking for the DL service + data flow is supported, when it is included and set to 'true'. The + default value is 'false' if omitted."; + } + leaf timetoNextBurstInd { + type boolean; + default false; + description "It indicates the Time to Next Burst for the DL service data + flow is supported, when it is included and set to 'true'. The default + value is 'false' if omitted."; + } + leaf dataEndMarkInd { + type boolean; + default false; + description "It indicates the Data End marking for + the DL service data flow is supported, when it is + included and set to 'true'. The default value is + 'false' if omitted."; + reference "3GPP TS 29.512"; + } + } + + grouping TrafficParaDataGrp { + description "This data type represents the Traffic + Parameter(s) related control information."; + reference "3GPP TS 29.512 clause 5.6.2.56"; + + leaf periodUl { + type uint32; + description "It indicates the time period between + the start of the two data bursts in units of + milliseconds in Uplink direction."; + //optional + } + + leaf periodDl { + type uint32; + description "It indicates the time period between + the start of the two data bursts in units of + milliseconds in Downlink direction."; + //optional + } + + leaf-list reqTrafficParas { + type enumeration { + enum DL_N6_JITTER; + enum DL_PERIOD; + enum UL_PERIOD; + } + min-elements 1; + description "Indicates the traffic parameters to + be measured."; + //optional + } + + leaf-list repFreqs { + type enumeration { + enum EVENT_TRIGGERED; + enum PERIODIC; + } + min-elements 1; + description "It represents the notification method + (periodic or on event detection). It shall be + present if the reqTrafficParas attribute is + present."; + //optional + } + + leaf dlN6JitterThr { + type uint32; + description "It indicates threshold for the N6 + Jitter Information associated with downlink + Periodicity that triggers the report of the + traffic parameters indicated in the + reqTrafficParas attribute. Only applicable when + the repFreqs attribute includes the value + EVENT_TRIGGERED."; + //optional + } + + leaf repPeriod { + type uint32; + description "Indicates the time interval between + successive event notifications. Only applicable + when the repFreqs attribute includes the value + PERIODIC."; + //optional } } grouping ARP { - description "It specifies the allocation and retention priority of a QoS control policy."; + description "It specifies the allocation and retention priority of + a QoS control policy."; leaf priorityLevel { type uint8 { range 1..15; @@ -343,7 +504,9 @@ module _3gpp-5gc-nrm-predefinedpccruleset { enum MAY_PREEMPT; } mandatory true; - description "It defines whether a service data flow may get resources that were already assigned to another service data flow with a lower priority level."; + description "It defines whether a service data flow may get resources + that were already assigned to another service data flow with a lower + priority level."; } leaf preemptVuln { type enumeration { @@ -351,12 +514,16 @@ module _3gpp-5gc-nrm-predefinedpccruleset { enum PREEMPTABLE; } mandatory true; - description "It defines whether a service data flow may lose the resources assigned to it in order to admit a service data flow with higher priority level."; + description "It defines whether a service data flow may lose the + resources assigned to it in order to admit a service data flow + with higher priority + level."; } } grouping QosDataInformation { - description "It specifies the QoS control policy data for a service flow of a PCC rule."; + description "It specifies the QoS control policy data for a service flow of + a PCC rule."; leaf qosId { type string; mandatory true; @@ -389,38 +556,46 @@ module _3gpp-5gc-nrm-predefinedpccruleset { leaf qosNotificationControl { type boolean; default false; - description "It indicates whether notifications are requested from 3GPP NG-RAN when the GFBR can no longer (or again) be guaranteed for a QoS Flow during the lifetime of the QoS Flow."; + description "It indicates whether notifications are requested from + 3GPP NG-RAN when the GFBR can no longer (or again) be guaranteed + for a QoS Flow during the lifetime of the QoS Flow."; } leaf reflectiveQos { type boolean; default false; - description "Indicates whether the QoS information is reflective for the corresponding non-GBR service data flow"; + description "Indicates whether the QoS information is reflective for + the corresponding non-GBR service data flow"; } leaf sharingKeyDl { type string; - description "It indicates, by containing the same value, what PCC rules may share resource in downlink direction."; + description "It indicates, by containing the same value, what PCC rules + may share resource in downlink direction."; } leaf sharingKeyUl { type string; - description "It indicates, by containing the same value, what PCC rules may share resource in uplink direction."; + description "It indicates, by containing the same value, what PCC rules + may share resource in uplink direction."; } leaf maxPacketLossRateDl { type uint16 { range 0..1000; } - description "It indicates the downlink maximum rate for lost packets that can be tolerated for the service data flow."; + description "It indicates the downlink maximum rate for lost packets + that can be tolerated for the service data flow."; } leaf maxPacketLossRateUl { type uint16 { range 0..1000; } - description "It indicates the uplink maximum rate for lost packets that can be tolerated for the service data flow."; + description "It indicates the uplink maximum rate for lost packets that + can be tolerated for the service data flow."; } leaf extMaxDataBurstVol { type uint32 { range 4096..2000000; } - description "It denotes the largest amount of data that is required to be transferred within a period of 5G-AN PDB, see TS 29.512"; + description "It denotes the largest amount of data that is required to + be transferred within a period of 5G-AN PDB, see TS 29.512"; } } @@ -441,7 +616,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } leaf fDesc { type string; - description "It contains the flow description for the Uplink or Downlink IP flow. It shall be present when the ethtype is IP."; + description "It contains the flow description for the Uplink or + Downlink IP flow. It shall be present when the ethtype is IP."; } leaf fDir { type enumeration { @@ -468,11 +644,17 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } leaf srcMacAddrEnd { type string; - description "It specifies the source MAC address end. If this attribute is present, the sourceMacAddr attribute specifies the source MAC address start. E.g. srcMacAddrEnd with value 00-10-A4-23-3E-FE and sourceMacAddr with value 00-10-A4-23-3E-02 means all MAC addresses from 00-10-A4-23-3E-02 up to and including 00-10-A4-23-3E-FE."; + description "It specifies the source MAC address end. If this attribute + is present, the sourceMacAddr attribute specifies the source MAC address + start. E.g. srcMacAddrEnd with value 00-10-A4-23-3E-FE and + sourceMacAddr with value 00-10-A4-23-3E-02 means all MAC addresses + from 00-10-A4-23-3E-02 up to and including 00-10-A4-23-3E-FE."; } leaf destMacAddrEnd { type string; - description "It specifies the destination MAC address end. If this attribute is present, the destMacAddr attribute specifies the destination MAC address start."; + description "It specifies the destination MAC address end. If this + attribute is present, the destMacAddr attribute specifies the + destination MAC address start."; } } @@ -497,7 +679,8 @@ module _3gpp-5gc-nrm-predefinedpccruleset { leaf tosTrafficClass { type string; mandatory true; - description "It contains the Ipv4 Type-of-Service and mask field or the Ipv6 Traffic-Class field and mask field."; + description "It contains the Ipv4 Type-of-Service and mask field or the + Ipv6 Traffic-Class field and mask field."; } leaf spi { type string; @@ -517,7 +700,205 @@ module _3gpp-5gc-nrm-predefinedpccruleset { enum UNSPECIFIED; } mandatory true; - description "It indicates the direction/directions that a filter is applicable."; + description "It indicates the direction/directions that a filter is + applicable."; + } + } + + grouping RtpHeaderExtInfoGrp { + description "It contains information on the RTP header + extension that can be used for PDU Set identification, + End of Data Burst marking, Data Burst Size marking + and/or Time to Next Burst marking."; + reference "3GPP TS 29.571"; + + leaf rtpHeaderExtType { + type enumeration { + enum PDU_SET_MARKING; + enum DYN_CHANGING_TRAFFIC_CHAR; + } + description "It indicates the RTP header extension + type. Extension that can be used for: + - PDU Set identification and/or End of Data Burst + marking; or + - Data Burst Size marking and/or Time to Next + Burst marking."; + } + + leaf rtpHeaderExtId { + type uint8 { + range "1..255"; + } + description "It represents the Id of the RTP header + extension identified by the rtpHeaderExtType."; + } + + leaf longFormat { + type boolean; + description "It indicates if a short or a long header + extension format is used. + true: 2-byte (long) format is used + false: 1-byte (short) format is used"; + } + + leaf pduSetSizeActive { + type boolean; + description "It indicates if the PDU Set size in bytes + is present in the RTP header extension of every RTP + packet. + true: PDU Set size is present + false: PDU Set size is not present"; + } + + leaf pduSetPduCountActive { + type boolean; + description "It indicates if the number of PDUs of a + PDU Set is present in the RTP header extension of + every RTP packet. + true: Number of PDUs of PDU Set is present + false: Number of PDUs of PDU Set is not present"; + } + } + + grouping RtpPayloadInfoGrp { + description "This data type specifies the RtpPayloadInfo, + see TS 29.571."; + reference "3GPP TS 29.571"; + + leaf-list rtpPayloadTypeList { + type uint8 { + range "0..127"; + } + min-elements 1; + description "It contains the list of Payload Type (PT) + values in the RTP header of RTP packets the UPF may + parse to derive the PDU Set Information."; + } + + leaf rtpPayloadFormat { + type enumeration { + enum H264; + enum H265; + } + description "It indicates the RTP Payload format."; + } + } + + grouping ProtocolDescriptionGrp { + description "This data type specifies the ProtocolDescription, + see TS 29.571."; + reference "3GPP TS 29.571"; + + leaf transportProto { + type enumeration { + enum RTP; + enum SRTP; + enum MOQT; + //optional + } + description "It indicates the transport protocol used by + the media flow."; + } + + list rtpHeaderExtInfo { + description "It contains information on the RTP header + extension that can be used for PDU Set identification, + End of Data Burst marking, Data Burst Size marking + and/or Time to Next Burst marking."; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses RtpHeaderExtInfoGrp; + //optional + } + + list addRtpHeaderExtInfo { + description "It contains information on additional RTP + header extensions."; + min-elements 1; + key idx; + leaf idx { type uint32; } + uses RtpHeaderExtInfoGrp; + //optional + } + + list rtpPayloadInfoList { + description "It contains RTP Payload information for + the RTP stream."; + min-elements 1; + key idx; + leaf idx { type uint32; } + uses RtpPayloadInfoGrp; + //optional + } + + leaf mriTransferInfo { + type enumeration { + enum UDP_OPTION; + //optional + } + description "It indicates how media related information + is transferred for end-to-end encrypted traffic."; + } + } + + grouping QoSMonitoringDataGrp { + description "This data type specifies the QosMonitoringData, + see clause 5.6.2.40 in TS 29.512."; + reference "3GPP TS 29.512 clause 5.6.2.40"; + + leaf qmId { + type string; + mandatory true; + description "It identifies the QoS monitoring policy data + within a PDU session."; + } + + leaf qosMonParamType { + type enumeration { + enum PACKET_DELAY; + enum CONGESTION; + enum DATA_RATE; + enum AVAILABLE_BITRATE; + } + description "It indicates the type of QoS monitoring + parameter."; + } + + leaf-list reqQosMonParams { + type enumeration { + enum DOWNLINK; + enum UPLINK; + enum ROUND_TRIP; + enum DOWNLINK_DATA_RATE; + enum UPLINK_DATA_RATE; + enum DOWNLINK_CONGESTION; + enum UPLINK_CONGESTION; + enum DOWNLINK_AVAILABLE_BITRATE; + enum UPLINK_AVAILABLE_BITRATE; + } + min-elements 1; + description "It indicates QoS information to be monitored + when the QoS Monitoring is enabled for the service + data flow."; + } + + leaf repFreqs { + type enumeration { + enum EVENT_TRIGGERED; + enum PERIODIC; + } + mandatory true; + description "It indicates the frequency for the reporting + for the indicated QoS monitoring parameter."; + } + + leaf repPeriod { + type uint32; + description "It indicates the reporting period in units + of seconds. Only applicable when the repFreqs attribute + includes the value PERIODIC."; + //optional } } @@ -545,10 +926,12 @@ module _3gpp-5gc-nrm-predefinedpccruleset { leaf appDescriptor { type string; description "It is the ATSSS rule application descriptor."; + //optional } leaf contentVersion { type uint8; description "Indicates the content version of the PCC rule."; + //optional } leaf precedence { type uint8 { @@ -564,17 +947,20 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } description "Indicates the protocol used for signalling between the UE and the AF, the default value is NO_INFORMATION."; + //optional } leaf isAppRelocatable { type boolean; default false; description "It indicates the application relocation possibility, the default value is NO_INFORMATION."; + //optional } leaf isUeAddrPreserved { type boolean; default false; description "It Indicates whether UE IP address should be preserved."; + //optional } container qosData { description "It contains the QoS control policy data for a PCC rule."; @@ -591,52 +977,139 @@ module _3gpp-5gc-nrm-predefinedpccruleset { description "The list of QoS control policy data."; key "qosId"; uses QosDataInformation; + //optional } } container trafficControlData { - description "It contains the traffic control policy data for a PCC rule."; + description "It contains the traffic control policy data for a PCC + rule."; list trafficControlDataInfo { description "The list of traffic control policy data."; key "tcId"; - uses TrafficControlDataInformation; + uses TrafficControlDataGrp; } } uses ConditionData; container tscaiInputUl { - description "It contains transports TSCAI input parameters for TSC traffic at the ingress interface of the DS-TT/UE (uplink flow direction)."; + description "It contains transports TSCAI input parameters for TSC + traffic at the ingress interface of the DS-TT/UE (uplink flow + direction)."; uses TscaiInputContainer; + //optional } container tscaiInputDl { - description "It contains transports TSCAI input parameters for TSC traffic at the ingress of the NW-TT (downlink flow direction)."; + description "It contains transports TSCAI input parameters for TSC + traffic at the ingress of the NW-TT (downlink flow direction)."; uses TscaiInputContainer; + //optional } leaf easRedisIndRequired { type boolean; default false; - description "Indicates whether the EAS rediscovery is required for the application."; + description "Indicates whether the EAS rediscovery is required for the + application."; + //optional } leaf tscaiTimeDom { type uint32; - description "Indicates the (g)PTP domain that the (TSN)AF is located in."; + description "Indicates the (g)PTP domain that the (TSN)AF is located + in."; + //optional } leaf capBatNotificationCapable { type boolean; default false; - description "Indicates the capability for AF to adjust the burst sending time."; + description "Indicates the capability for AF to adjust the burst + sending time."; + //optional } leaf ueNotifEnabled { type boolean; default false; - description "Indicates whether QoS flow parameter signalling to the UE is enabled (TRUE), when the SMF is notified by the NG-RAN of changes in the fulfilled QoS situation,"; + //optional + description "Indicates whether QoS flow parameter signalling to the UE is + enabled (TRUE), when the SMF is notified by the NG-RAN of changes in the + fulfilled QoS situation,"; } leaf packFiltAllPrec { type uint32; - description "Determines the order of TFT packet filter allocation for PCC rules."; + description "Determines the order of TFT packet filter allocation for + PCC rules."; + //optional } leaf nscSupportedFeats { type uint32; - description "Indicates the Network Function Service Consumer features supported per service."; + description "Indicates the Network Function Service + Consumer features supported per service."; + //optional + } + + list qosMonData { + description "It contains QoS monitoring related control + information, see clause 5.6.2.40 in TS 29.512."; + max-elements 1; + key "qmId"; + uses QoSMonitoringDataGrp; + //optional + } + + list protoDescDl { + description "It represents the downlink protocol + description for the identification of the DL packets + of the PDU Set, the detection of the last packet of + the data burst, the detection of the Data Burst Size, + and/or indication of whether MoQ or UDP-option is used + to carry media related information."; + reference "3GPP TS 29.512"; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses ProtocolDescriptionGrp; + //optional + } + + list protoDescUl { + description "It represents the uplink protocol description + for the identification of the UL packets of the PDU Set + in the UE."; + reference "3GPP TS 29.512"; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses ProtocolDescriptionGrp; + //optional + } + + leaf expTranInd { + type boolean; + default false; + description "It represents the Expedited Transfer + Indication for the downlink traffic to enable + expedited data transfer with reflective QoS for + the non-GBR service data flow."; + //optional + } + + leaf multiModalId { + type string; + description "It represents the Multi-modal Service + Identifier."; + reference "see clause 5.6.3.2 in TS 29.514"; + //optional + } + + list traffParaData { + description "It contains Traffic Parameter(s) related + control information providing assistance information + that enable UE power saving management for XRM + service."; + reference "3GPP TS 29.512"; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses TrafficParaDataGrp; + //optional } } @@ -650,25 +1123,29 @@ module _3gpp-5gc-nrm-predefinedpccruleset { } grouping PredefinedPccRuleSetSubtree { - description "It specifies the PredefinedPccRuleSet IOC with inherited attributes."; + description "It specifies the PredefinedPccRuleSet IOC with inherited + attributes."; list PredefinedPccRuleSet { description "Specifies the predefined PCC rules."; key "id"; uses top3gpp:Top_Grp; container attributes { - description "It contains the attributes defined specifically in the PredefinedPccRuleSet IOC."; + description "It contains the attributes defined specifically in the + PredefinedPccRuleSet IOC."; uses PredefinedPccRuleSetGrp; } } } augment "/me3gpp:ManagedElement/smf3gpp:SMFFunction" { - description "It specifies the containment relation of PredefinedPccRuleSet MOI with SMFFunction MOI."; + description "It specifies the containment relation of + PredefinedPccRuleSet MOI with SMFFunction MOI."; uses PredefinedPccRuleSetSubtree; } augment "/me3gpp:ManagedElement/pcf3gpp:PCFFunction" { - description "It specifies the containment relation of PredefinedPccRuleSet MOI with PCFFunction MOI."; + description "It specifies the containment relation of + PredefinedPccRuleSet MOI with PCFFunction MOI."; uses PredefinedPccRuleSetSubtree; } } \ No newline at end of file diff --git a/yang-models/_3gpp-5gc-nrm-udmfunction.yang b/yang-models/_3gpp-5gc-nrm-udmfunction.yang index 6fc1e8793f52dacddb2e6ae1831a9818775a60ae..b609689b0bad992ecba092c18b11c7af69ad77e7 100755 --- a/yang-models/_3gpp-5gc-nrm-udmfunction.yang +++ b/yang-models/_3gpp-5gc-nrm-udmfunction.yang @@ -84,25 +84,28 @@ module _3gpp-5gc-nrm-udmfunction { list supiRanges { description "List of ranges of SUPI's whose profile data is available in the UDM instance."; - key "start end pattern"; + key idx; + leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:SupiRangeGrp; + uses types5g3gpp:SupiRangeGrp; } list gpsiRanges { description "List of ranges of GPSIs whose profile data is available in the UDM instance."; - key "start end pattern"; + key idx; + leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list externalGroupIdentifiersRanges { description "List of ranges of external groups whose profile data is available in the UDM instance."; - key "start end pattern"; + key idx; + leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } leaf-list routingIndicators { diff --git a/yang-models/_3gpp-5gc-nrm-udrfunction.yang b/yang-models/_3gpp-5gc-nrm-udrfunction.yang index 5f9ff10286ac9b87ac124febb175001c8a8c712d..e6d4ec66aa9ed4e3fe57a0c83fab40457db08908 100755 --- a/yang-models/_3gpp-5gc-nrm-udrfunction.yang +++ b/yang-models/_3gpp-5gc-nrm-udrfunction.yang @@ -41,25 +41,28 @@ module _3gpp-5gc-nrm-udrfunction { list supiRanges { description "List of ranges of SUPI's whose profile data is available in the UDR instance."; - key "start end pattern"; + key idx; + leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:SupiRangeGrp; + uses types5g3gpp:SupiRangeGrp; } list gpsiRanges { description "List of ranges of GPSIs whose profile data is available in the UDR instance."; - key "start end pattern"; + key idx; + leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } list externalGroupIdentifiersRanges { description "List of ranges of external groups whose profile data is available in the UDR instance."; - key "start end pattern"; + key idx; + leaf idx { type uint32; } min-elements 1; - uses mnfp3gpp:IdentityRange; + uses types5g3gpp:IdentityRangeGrp; } leaf-list supportedDataSets { diff --git a/yang-models/_3gpp-5gc-nrm-upffunction.yang b/yang-models/_3gpp-5gc-nrm-upffunction.yang index ce54974048ec977d9628a8083b630653ed925a60..f23140e7d21916937d2e622ac40553be0b1a4d0b 100755 --- a/yang-models/_3gpp-5gc-nrm-upffunction.yang +++ b/yang-models/_3gpp-5gc-nrm-upffunction.yang @@ -15,11 +15,11 @@ module _3gpp-5gc-nrm-upffunction { organization "3GPP SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; description "UPFFunction derived from basic ManagedFunction. - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.541 5G Network Resource Model (NRM)"; - revision 2025-07-25 { reference CR-1558 ; } + revision 2026-03-20 { reference CR-1695 ; } revision 2025-07-25 { reference CR-1558 ; } revision 2024-05-24 { reference CR-1273 ; } revision 2023-09-18 { reference CR-1043 ; } @@ -232,7 +232,7 @@ module _3gpp-5gc-nrm-upffunction { leaf atsssLL { description "Indicates the ATSSS-LL capability to support procedures related to Access Traffic Steering, Switching, Splitting - (see clauses 4.2.10, 5.32 of TS 23.501). + (see clauses 4.2.10, 5.32 of TS 23.501, clauses 5.6.3.18 of TS 28.512)). true: Supported false: Not Supported"; type boolean; @@ -242,13 +242,40 @@ module _3gpp-5gc-nrm-upffunction { leaf mptcp { description "Indicates the MPTCP capability to support procedures related to Access Traffic Steering, Switching, Splitting - (see clauses 4.2.10, 5.32 of TS 23.501). + (see clauses 4.2.10, 5.32 of TS 23.501, clauses 5.6.3.18 of TS 28.512). true: Supported false: Not Supported"; type boolean; default false; } + leaf mpQuicUdp { + type boolean; + default false; + description "Indicates the support of Access Traffic Steering, Switching + and Splitting procedures using the MPQUIC-UDP steering functionality + (see clauses 4.2.10, 5.32 of 3GPP TS 23.501, + clauses 5.6.3.18 of TS 28.512)."; + } + + leaf mpQuicIp { + type boolean; + default false; + description "Indicates the support of Access Traffic Steering, Switching + and Splitting procedures using the MPQUIC-IP steering functionality + (see clauses 4.2.10, 5.32 of 3GPP TS 23.501, + clauses 5.6.3.18 of TS 28.512)."; + } + + leaf mpQuicE { + type boolean; + default false; + description "Indicates the support of Access Traffic Steering, Switching + and Splitting procedures using the MPQUIC-E steering functionality + (see clauses 4.2.10, 5.32 of 3GPP TS 23.501, + clauses 5.6.3.18 of TS 28.512)."; + } + leaf rttWithoutPmf { description "Indicates whether the UPF supports RTT measurement without PMF (see clauses 5.32.2, 6.3.3.3 of TS 23.501). diff --git a/yang-models/_3gpp-common-externaldata.yang b/yang-models/_3gpp-common-externaldata.yang index 0854e9f887f1e28659f9b9e51b973a5696f24425..6ed95bf8bb14c0e1a1e66a47046fc5126d4f2149 100644 --- a/yang-models/_3gpp-common-externaldata.yang +++ b/yang-models/_3gpp-common-externaldata.yang @@ -11,10 +11,11 @@ module _3gpp-common-externaldata { organization "3GPP SA5"; contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; description "Defines the YANG mapping of the external data. - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.623 Generic Network Resource Model (NRM)"; + revision 2026-03-20 { reference CR-0619; } revision 2025-07-19 { reference CR-0551; } grouping ExternalDataScopeGrp { @@ -48,8 +49,8 @@ module _3gpp-common-externaldata { description "Type of external management data as defined by the implementation. - Examples: 'Electronic Map', 'Camara Data', 'UE path', 'Camera Photo', - 'Event Schedule”"; + Examples of allowed value: 'ELECTRONIC_MAP','CAMARA_DATA', 'UE_PATH', + 'CAMERA_PHOTO', 'EVENT_SCHEDULE', 'WEATHER_FORECASTS'"; } leaf-list mediaLocation { diff --git a/yang-models/_3gpp-common-mnsregistry.yang b/yang-models/_3gpp-common-mnsregistry.yang index 4521f20811598610839f637829bf07a27f528780..f606c3acbe1d2c22d6040f1c0a004175c9a17d94 100755 --- a/yang-models/_3gpp-common-mnsregistry.yang +++ b/yang-models/_3gpp-common-mnsregistry.yang @@ -13,10 +13,11 @@ module _3gpp-common-mnsregistry { contact "https://www.3gpp.org/DynaReport/TSG-WG--S5--officials.htm?Itemid=464"; description "Defines the YANG mapping of the MNSRegistry IOC and its contained classes that ares part of the Generic Network Resource Model (NRM). - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.623 Generic Network Resource Model (NRM)"; + revision 2026-03-20 { reference CR-0619; } revision 2025-11-02 { reference CR-; } revision 2025-07-19 { reference CR-0551; } revision 2023-09-30 { reference CR-0278; } @@ -259,12 +260,12 @@ module _3gpp-common-mnsregistry { augment "/subnet3gpp:SubNetwork" { list MnsRegistry { - description "This IOC is a container for MnsInfo IOC-s. It can be - contained only by SubNetwork IOC. A SubNetwork IOC can contain - only one instance of MnsRegistry. + description "TThis IOC is a container for MnsInfo IOC and MgmtDataInfo + IOC. It can be contained only by SubNetwork IOC. The IOC is instantiated by the system."; key id; max-elements 1; + yext3gpp:only-system-created; uses top3gpp:Top_Grp; container attributes { uses MnsRegistryGrp; diff --git a/yang-models/_3gpp-common-subscription-control.yang b/yang-models/_3gpp-common-subscription-control.yang index 8fbbbdf949ce04a4cae0823043b6051990e7f318..833e46ad59066ea86ad5c776a03592b055309778 100755 --- a/yang-models/_3gpp-common-subscription-control.yang +++ b/yang-models/_3gpp-common-subscription-control.yang @@ -13,7 +13,7 @@ module _3gpp-common-subscription-control { description "Defines IOCs for subscription, notification list and heartbeat control. - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.623 Generic Network Resource Model (NRM) @@ -21,7 +21,8 @@ module _3gpp-common-subscription-control { Solution Set (SS) definitions 3GPP TS 28.623"; - revision 2025-11-07 { reference "CR-0551 CR-0586"; } //common for r19, r20 + revision 2026-03-19 { reference "CR-0618 CR-0619"; } //common for r19, r20 + revision 2025-11-07 { reference "CR-0551 CR-0586"; } revision 2025-08-13 { reference "CR-0551 CR-0561"; } revision 2025-05-13 { reference "CR-0548"; } revision 2025-03-24 { reference "CR-0516 0518"; } @@ -331,6 +332,7 @@ module _3gpp-common-subscription-control { type uint64; config false; mandatory true; + yext3gpp:notNotifyable; description "The sequence number of the last notification that was sent by a 'NtfSubscriptionControl' instance."; } diff --git a/yang-models/_3gpp-common-trace.yang b/yang-models/_3gpp-common-trace.yang index 8eeee60b7f0844835fbfad9f6ceb105e26a4c6ad..092fb7bd4dc397b39789068a3ebba6a70d5d15fe 100755 --- a/yang-models/_3gpp-common-trace.yang +++ b/yang-models/_3gpp-common-trace.yang @@ -25,6 +25,8 @@ module _3gpp-common-trace { Integration Reference Point (IRP); Information Service (IS)" ; + revision 2026-04-02 { reference "CR-0624" ; } + revision 2026-03-20 { reference "CR-0619" ; } revision 2026-02-08 { reference "CR-1683" ; } revision 2025-11-07 { reference "CR-0553" ; } revision 2025-10-07 { reference "CR-0573" ; } @@ -746,6 +748,75 @@ module _3gpp-common-trace { } } + grouping EventTriggerConfigGrp { + description "Represent the EventTriggerConfig data type. Defines the + configuration parameters of trigger event used for M10 measurement in NR. + For details, please refer to TS 32.422 subclause 5.10.45."; + + leaf eventType { + type enumeration { + enum eventA1 { value 0; } + enum eventA2 { value 1; } + } + mandatory true; + description "It indicates the event type. Either Event A1 or Event A2 + can be configured. See also clause 5.10.45 of TS 32.422."; + } + + leaf thresholdRAN { + type uint8 { + range 0..127; + } + mandatory true; + description "Threshold parameter for an event. It is used to define the + entering and leaving condition of the event. For further details see + RSRP-Range in TS 38.331. See also clause 5.10.45 of TS 32.422"; + } + + leaf measurementQuantityRAN { + type int32; + mandatory true; + description "It indicates the measurement quantity. For further details + see MeasTriggerQuantity in TS 38.331. See also clause 5.10.45 of + TS 32.422"; + } + + leaf hysteresisRAN { + type uint8 { + range 0..30; + } + mandatory true; + description "Hysteresis parameter for an event. It is used to define the + entering and leaving condition of the event. For further details see + Hysteresis in TS 38.331. See also clause 5.10.45 of TS 32.422"; + } + + leaf timeToTriggerRAN { + type enumeration { + enum 0ms { value 0; } + enum 40ms { value 1; } + enum 64ms { value 2; } + enum 80ms { value 3; } + enum 100ms { value 4; } + enum 128ms { value 5; } + enum 160ms { value 6; } + enum 256ms { value 7; } + enum 320ms { value 8; } + enum 480ms { value 9; } + enum 512ms { value 10; } + enum 640ms { value 11; } + enum 1024ms { value 12; } + enum 1280ms { value 13; } + enum 2560ms { value 14; } + enum 5120ms { value 15; } + } + mandatory true; + description "It defines the time during which specific criteria for the + event needs to be met in order to trigger an action. + For further details see TimeToTrigger in TS 38.331 and clause 5.10.45 of TS 32.422."; + } + } + grouping ImmediateMdtConfigGrp { description "Represents the ImmediateMdtConfig dataType. This <> defines the configuration parameters of @@ -784,6 +855,8 @@ module _3gpp-common-trace { -measurementQuantity (conditional for 1F event reporting), -beamLevelMeasurement (conditional for M1 in NR), -excessPacketDelayThresholds (conditional for M6 UL measurement in NR). + -layerOneRsrpPeriodicity (conditional for M10 measurements in NR), + -eventTriggerConfig (conditional for event reporting for M10 measuremen For immediate MDT, the measurement reporting is dependent on the configured measurements: @@ -841,6 +914,13 @@ module _3gpp-common-trace { - Measurements M8 and M9 in NR or LTE are reported according to configured M1 and/or M6 related UE measurement reporting. + - For management based Immediate MDT M10 measurements + layerOneRsrpPeriodicity in NR, the + measurement is optionally triggered with periodically or event based . + The parameter layerOneRsrpPeriodicity determines the interval between + two successive UE measurements. If parameter eventTriggerConfig is + configured, the logging is performed only at the condition indicated + by eventTriggerConfigis met. "; leaf listOfMeasurements { @@ -865,6 +945,7 @@ module _3gpp-common-trace { enum M7; enum M8; enum M9; + enum M10; } description "It specifies the UE measurements that shall be collected in an Immediate MDT job. The attribute is @@ -1396,6 +1477,26 @@ module _3gpp-common-trace { measurements and applicable only for NR."; reference "Clause 5.10.6 of TS 32.422."; } + + leaf layerOneRsrpPeriodicity { + type enumeration { + enum 2 {value 0; } + enum 3 {value 1; } + enum 4 {value 2; } + enum 5 {value 3; } + } + description "It defines the periodicity that the UE shall use for the + M10 measurements."; + } + + list eventTriggerConfig { + description "It specifies the event-triggered configuration used for M10 + measurements."; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses EventTriggerConfigGrp; + } } grouping LoggedMdtConfigGrp { @@ -1624,7 +1725,9 @@ module _3gpp-common-trace { the attribute loggedMdtConfig are applicable. The optional attribute plmnList allows to specify the PLMNs where - measurements collection, status indication and log reporting is allowed."; + measurements collection, status indication and log reporting is allowed. + For NTN MDT, if the list of plmnList is included, it will only log + measurements for the cells belonging to the listed PLMNs."; leaf anonymizationOfMdtData { when ../areaScope ; @@ -2087,7 +2190,8 @@ module _3gpp-common-trace { description "A TraceJob instance represents the Trace Control and Configuration parameters of a particular Trace Job (see TS 32.421 and TS 32.422 for details). It can be name-contained by SubNetwork, - ManagedElement, ManagedFunction. + ManagedElement, ManagedFunction. In case of signalling based trace + activation, it shall be name-contained by the UDMFunction, see TS 28.541. To activate Trace Jobs, a MnS consumer has to create TraceJob object instances on the MnS producer. A MnS consumer can activate a Trace Job @@ -2099,15 +2203,14 @@ module _3gpp-common-trace { 4.1.2.1.2 of TS 32.422. When a MnS consumer wishes to deactivate a Trace Job, the MnS consumer - shall delete the corresponding TraceJob instance. - - For details of management Trace Job activation/deactivation see clause - 4.1.1.1.2 of TS 32.422. + shall delete the corresponding TraceJob instance. For details of + management Trace Job deactivation see clauses 4.1.3.8 to 4.1.3.11 a + nd 4.1.4.10 to 4.1.4.13 of TS 32.422 The attribute traceReference specifies a globally unique ID and identifies a Trace session. One Trace Session may be activated to multiple Network Elements. The traceReference is populated by the - consumer that makes the request for a Trace Session. + consumer that makes the request for a Trace Session, TS 32.422. The jobId attribute presents the job identifier of a TraceJob instance. The jobId can be used to associate multiple TraceJob instances. @@ -2123,14 +2226,15 @@ module _3gpp-common-trace { stream-based reporting the attribute traceReportingConsumerUri specifies the streaming target. - The mandatory attribute traceTarget determines the target object of - the TraceJob. Dependent on the network element to which the Trace - Session is activated different types of the target object are possible. + The attribute traceTarget determines the target object of the + TraceJob. Dependent on the network element to which the Trace Session + is activated different types of the target object are possible. + The attribute pLMNTarget defines the PLMN for which sessions shall be selected in the Trace Session in case of management based activation - when several PLMNs are supported in the RAN.The MDT configuration may - include area scope defined by network slice, in which case - the attribute pLMNTarget is not applicable. + when several PLMNs are supported in the RAN. The MDT configuration + may include area scope defined by network slice, in which case the + attribute pLMNTarget is not applicable. The attribute listOfTraceMetrics allows configuraton of which metrics shall be recorded. diff --git a/yang-models/_3gpp-common-yang-types.yang b/yang-models/_3gpp-common-yang-types.yang index 4f5e0db9b9d0873a68175903815ae6ebbaa20afc..5db3ef639e5f35f0073854969f941c7e86e69bd1 100755 --- a/yang-models/_3gpp-common-yang-types.yang +++ b/yang-models/_3gpp-common-yang-types.yang @@ -12,11 +12,12 @@ module _3gpp-common-yang-types { description "The model defines a YANG mapping of the top level information classes used for management of 5G networks and network slicing. - Copyright 2025, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, + Copyright 2026, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TSDSI, TTA, TTC). All rights reserved."; reference "3GPP TS 28.623"; - // common for rel-19, rel-20 + revision 2026-03-25 { reference "CR-xxxx"; } + revision 2026-03-20 { reference "CR-0619"; } revision 2025-10-07 { reference "CR-0573 CR-0582 CR-583"; } revision 2025-10-01 { reference "CR-0578" ; } revision 2025-08-31 { reference "CR-0551 CR-0556 CR-0562"; } @@ -657,11 +658,13 @@ module _3gpp-common-yang-types { description "a geographical circle identified by reference location and associated distance radius"; - leaf referenceLocation { - description "Reference location of the serving cell provided via NTN - (quasi)-Earth fixed cell. This field is only present in an NTN cell. - It is defined as ReferenceLocation-r17 in TS 38.331"; - type string; + list referenceLocation { + description "Specifies a fixed geographic coordinate point, + see TS 38.331."; + min-elements 1; + max-elements 1; + key "latitude longitude altitude"; + uses GeoCoordinateGrp; } leaf distanceRadius { @@ -669,6 +672,7 @@ module _3gpp-common-yang-types { coordinates reference point, defined by referenceLocation. Each value represents 50m distance. This field is only present in an NTN cell."; type uint16; + mandatory true; units "50 meters"; } } @@ -676,14 +680,28 @@ module _3gpp-common-yang-types { grouping GeoAreaGrp { description "This data type defines a geographical area. The geo-area is either a 'geoPolygon' or a 'geoCircle'."; - - list geoPolygon { - description "Specifies the geographical area with a convex polygon. - The convex polygon is specified by its corners."; - key "latitude longitude"; - min-elements 3; - ordered-by user; - uses GeoCoordinateGrp; + + choice selectShape { + mandatory true; + list geoPolygon { + description "Specifies the geographical area with a convex polygon. + The convex polygon is specified by its corners."; + key "latitude longitude"; + min-elements 3; + ordered-by user; + uses GeoCoordinateGrp; + } + + list geoCircle { + description "It specifies the geographical area with a circle. A + geographical circle is identified by reference location and associated + distance radius."; + min-elements 1; + max-elements 1; + key idx; + leaf idx { type uint32; } + uses GeoCircleGrp; + } } } @@ -698,14 +716,6 @@ module _3gpp-common-yang-types { reference "clause 2.10.1 of 3GPP TS 23.003"; } - list geoCircle { - description "a geographical circle identified by reference location and - associated distance radius"; - key idx; - leaf idx { type uint16; } - uses GeoCircleGrp; - } - typedef AmfSetId { type union { type uint16 { @@ -790,6 +800,22 @@ module _3gpp-common-yang-types { range 0..100; } } + typedef SupportedFeatures { + type string { + pattern '[A-Fa-f0-9]*'; + } + description "It is a string, which indicates the features of the service + corresponding to the subscribed default notification, which are supported + by the NF (Service) instance acting as NF service consumer, when it is + present of the attribute whose type is DefaultNotificationSubscription + <>. When it is present as the attribute of an NFService + instance, it indicates the supported features of the NF Service + A string containing a bitmask indicating supported features in hexadecimal + representation. Each character in the string shall take + a value of 0 to 9, a to f or A to F and shall represent the support + of 4 features as described in table 5.2.2-3 of TS 29.571."; + reference "3GPP TS 29.571"; + } typedef N1MessageClass { type enumeration { @@ -869,7 +895,7 @@ module _3gpp-common-yang-types { reference "shall represent the support of 4 features as described in table 5.2.2-3 of TS 29.571 [61]."; //optional - type string; + type SupportedFeatures; config false; } leaf serviceInfoList {