Analyse 3GPP Network Resource Model

[oam.git] / model / yang / 3gpp / ts-28.541 / v16.1.0 / nrm-types-3gpp.yang

module nrm-types-3gpp {

  namespace "urn:3gpp:tsg:sa5:nrm:types";
  prefix "nrm-type";
    import ietf-inet-types { prefix inet; revision-date "2010-09-24"; }
    import ietf-yang-types { prefix yang; revision-date "2010-09-24"; }

  revision 2018-07-31 {
    description
     "Initial revision.";
    
  }

  typedef t_dn {
    type string;
    description
     "The dn type represents a Distinguish Name of the object.";
  }

  typedef t_mcc {
          description "The mobile country code consists of three decimal digits, The first digit of the mobile country code identifies the geographic region (the digits 1 and 8 are not used):";
          type string {
                  pattern '[02-79][0-9][0-9]';
          }
  }

  typedef t_mnc {
          description "the mobile network code consists of two or three decimal digits (for example: MNC of 001 is not the same as MNC of 01)";
          type string {
                  pattern '[0-9][0-9][0-9]|[0-9][0-9]';
          }
  }

  grouping pLMNId {
          leaf MCC {
                  type t_mcc;
          }
          leaf MNC {
                  type t_mnc;
          }
  }
  
  typedef t_NCI {
          description "The NCI shall be of fixed length of 36 bits and shall be coded using full hexadecimal representation. The exact coding of the NCI is the responsibility of each PLMN operator";
          reference "23.003";
          type union {
                  type string {
                          length 36;
                          pattern '[01]*';
                  }
                  type string {
                          length 9;
                          pattern '[a-fA-F0-9]*';
                  }
          }
  }
  
  
  typedef t_operationalState {
      type enumeration {
        enum "Enabled";
        enum "Disabled";                
      }
  }
  
  typedef t_administrativeState {
      type enumeration {
        enum "Locked";
        enum "Shutdown";                
        enum "Unlocked";                
     }
  }
  
  typedef t_availabilityStatus {
      type enumeration {
                enum "IN TEST";
                enum "FAILED";                                  
                enum "POWER OFF";                               
                enum "OFF LINE";                                
                enum "OFF DUTY";                                
                enum "DEPENDENCY";                              
                enum "DEGRADED";                                
                enum "NOT INSTALLED";                                   
                enum "LOG FULL";                                
       }
  }
  
  typedef t_cellState {
      type enumeration {
        enum "Idle";
        enum "Inactive";                
        enum "Active";                  
     }
  }

  typedef t_s-NSSAI {
          type union {
                  type uint8;
                  type uint32;
          }
  }
  
  typedef t_SST {
          type uint8;
  }
  
  typedef t_nRPCI {
          type uint32;
  }

  typedef t_tAC {
        type union {
          type string {
                  length 4;
                  pattern '[a-fA-F0-9]*';
          }
          type string {
                  length 6;
                  pattern '[a-fA-F0-9]*';
          }
        }
  }
  
  typedef t_subcarrierSpacing {
          type enumeration {
                  enum 15;
                  enum 30;
                  enum 60;
                  enum 120;
          }
  }

  typedef t_cyclicPrefix {
          type enumeration {
                  enum "Normal";
                  enum "Extended";
          }
  }
                          
  typedef t_aMF-Region-id {
          type string {
                  length 8;
                  pattern '[01]*';
          }
  }

  typedef t_aMF-Set-id {
      type string {
                  length 10;
                  pattern '[01]*';
          }
  }

  typedef t_aMF-Pointer {
          type string {
                  length 6;
                  pattern '[01]*';
          }
  }

                          
  grouping aMFI {
                          
          leaf AMF-Region-id {
                  type t_aMF-Region-id;
          }
          leaf AMF-Set-id {
                  type t_aMF-Set-id;
          }
          leaf AMF-Pointer {
                  type t_aMF-Pointer;
          } 
                          
  }             

  typedef t_TransportProtocol {
                type enumeration {
                          enum "TCP";
                          enum "STCP";
                          enum "UDP";
                }                 
  }

// type definition especially for core NF

  typedef NFType {
        type enumeration {
                enum "NRF";
                enum "UDM";
                enum "AMF";
                enum "SMF";
                enum "AUSF";
                enum "NEF";
                enum "PCF";
                enum "SMSF";
                enum "NSSF";
                enum "UDR";
                enum "LMF";
                enum "GMLC";
                enum "5G_EIR";
                enum "SEPP";
                enum "UPF";
                enum "N3IWF";
                enum "AF";
                enum "UDSF";
                enum "BSF";
                enum "CHF";
        }               
  }
  
  typedef NFStatus {
        type enumeration {
                enum "REGISTERED";
                enum "SUSPENDED";
        }
  }
  
  typedef NotificationType {
                type enumeration {
                        enum "N1_MESSAGES";
                        enum "N2_INFORMATION";
                        enum "LOCATION_NOTIFICATION";
                }       
  }
  
  typedef NotificationEventType {
                type enumeration {
                        enum "NF_REGISTERED";
                        enum "NF_DEREGISTERED";
                        enum "NF_PROFILE_CHANGED";
                }
  }
  
  typedef DataSetId {
                type enumeration {
                        enum "SUBSCRIPTION";
                        enum "POLICY";
                        enum "EXPOSURE";
                        enum "APPLICATION";
                }       
  }
  
  typedef UPInterfaceType {
                type enumeration {
                        enum "N3";
                        enum "N6";
                        enum "N9";
                }
  }
  
  typedef N1MessageClass {
                type enumeration {
                        enum "5GMM";
                        enum "SM";
                        enum "LPP";
                        enum "SMS"; 
                }       
  }
  
  typedef N2InformationClass {
                type enumeration {
                        enum "SM";
                        enum "NRPPa";
                        enum "PWS";
                        enum "PWS-BCAL";
                        enum "PWS-RF";
                }                       
  }
  
  typedef t_Load {
        description "Latest known load information of the NF ranged from 0 to 100 in percentage ";
        type uint8 {
                range 0..100;
        }
  }
 
  typedef SupportedFeatures {
        type string {
                pattern '[A-Fa-f0-9]*';
        }
  }
  
  grouping SupiRange {
        leaf start {
                type string;
        }
        
        leaf end {
                type string;
        }
        
        leaf pattern {
                type string;
        }       
  }
  
  grouping IdentityRange {
        leaf start {
                type string;
        }
        
        leaf end {
                type string;
        }
        
        leaf pattern {
                type string;
        }       
  }
  
  grouping Guami {
        container plmnId { uses pLMNId; }
        container amfId { uses aMFI; }
  }
        
  grouping Tai {
                container plmnId { uses pLMNId; }
                leaf tac { type t_tAC; }
  }
                
  typedef t_Dnn {
         type string;
  }
        
  grouping DnnUpfInfoItem {
        leaf dnn {
                type t_Dnn;
        }
  }
        
  grouping SnssaiUpfInfoItem {
    leaf sNssai {
        type t_s-NSSAI;
    }

        list dnnUpfInfo {
                key dnn;
                uses DnnUpfInfoItem;
        } 
        
  }

  grouping NFServiceVersion {
      description "";
        leaf apiVersionInUri {
          description "";
                type string;
        }
        
        leaf apiFullVersion {
                type string;  
          description "";       
      }
        
        leaf expiry {
          description "";
                type yang:date-and-time;
        }

  }
  
  grouping ipEndPoint {
        choice address {
                leaf ipv4Address {
                        type inet:ipv4-address;
                }
                leaf ipv6Address {
                        type inet:ipv6-address;                 
                }
                leaf ipv6Prefix {
                        type inet:ipv6-prefix;  
                }
        }
        
        leaf transport {
                type t_TransportProtocol;
        }
        
        leaf port {
                type uint16;
        }
  }
  
  grouping defaultNotificationSubscription {
        
        leaf notificationType {
                type NotificationType;
        }
        
        leaf callbackUri {
                type inet:uri;
        }
        
        leaf n1MessageClass {
                type N1MessageClass;
        }
        
        leaf n2InformationClass {
                type N2InformationClass;
        }       
  }  
        
  grouping InterfaceUpfInfoItem {

        leaf interfaceType {
                type UPInterfaceType;
        }
        
        choice address {
                leaf ipv4Address {
                        type inet:ipv4-address;
                }
                leaf ipv6Address {
                        type inet:ipv6-address;                 
                }
                leaf ipv6Prefix {
                        type inet:ipv6-prefix;  
                }
                leaf endpointFqdn {
                        type inet:domain-name;
                }
        }
        
        leaf networkInstance {
                type string;
        }

  }
        
  grouping Ipv4AddressRange {
        leaf start {
                type inet:ipv4-address;
        }
        leaf end {
                type inet:ipv4-address;
        }       
  }
        
  grouping Ipv6PrefixRange {
        leaf start {
                type inet:ipv6-prefix;
        }
        leaf end {
                type inet:ipv6-prefix;
        }       
  }
         
  typedef t_NsiId {
        type string;
  }
        
  typedef t_uEMobilityLevel {
        type enumeration {
                enum "stationary";
                enum "nomadic";
                enum "restricted mobility";
                enum "fully mobility";
        }
  }
                
  typedef t_resourceSharingLevel {
                type enumeration {
                        enum "shared";
                        enum "not-shared";
                }
  }
                
  typedef TxDirection {
                type enumeration {
                        enum "DL";
                        enum "UL";
                        enum "DL and UL";
                }
  }
                
  typedef BwpContext {
                type enumeration {
                        enum "DL";
                        enum "UL";
                        enum "SUL";
                }
  }
                
  typedef IsInitialBwp {
                type enumeration {
                        enum "INITIAL";
                        enum "OTHER";
                }
  }

  typedef t_quotaType {
                type enumeration {
                        enum "strict";
                        enum "float";
                }
  }

  grouping RRMPolicyRatio2{
        leaf groupId {
                type uint16;
        }
        leaf-list sNSSAI {
        type t_s-NSSAI; 
        }
        leaf quotaType {
                type t_quotaType;
        }
        leaf rRMPolicyMaxRation {
                type uint8;
        }
        leaf rRMPolicyMarginMaxRation {
                type uint8;
        }
        leaf rRMPolicyMinRation {
                type uint8;
        }
        leaf rRMPolicyMarginMinRation {
                type uint8;
        }
  }
}