module nokia-types-router {

    yang-version 1.1;

    namespace
      "urn:nokia.com:sros:ns:yang:sr:types-router";

    prefix types-router;

    import nokia-sros-yang-extensions {
      prefix sros-ext;
    }
    import nokia-types-sros {
      prefix types-sros;
    }

    organization "Nokia";

    contact
      "Nokia SR OS Support
         Web: <http://www.nokia.com>";

    description
      "Common router data types used in the SR OS management system.

         Copyright 2016 Nokia. All rights reserved. Reproduction of this document
         is authorized on the condition that the foregoing copyright notice is included.

         This nokia-types-router YANG module embodies Nokia's proprietary
         intellectual property. Nokia retains all title and ownership in the
         specification, including any revisions.

         Nokia grants all interested parties a non-exclusive license to use
         and distribute an unmodified copy of this specification in connection with
         management of Nokia products, and without fee, provided this
         copyright notice and license appear on all copies.

         This specification is supplied `as is', and Nokia makes no warranty,
         either express or implied, as to the use, operation, condition, or performance
         of the specification.";

    revision "2022-07-11";
    sros-ext:sros-major-release "rel22";

    typedef ip-ecmp {
      type uint32 {
        range "1..64";
      }
      description
        "The supported range of ECMP values for IP routes.";
    }

    typedef mpls-ecmp {
      type uint32 {
        range "1..32";
      }
      description
        "The supported range of ECMP value for MPLS tunnels.";
    }

    typedef urpf-check-mode {
      type enumeration {
        enum "strict" {
          value 1;
        }
        enum "loose" {
          value 2;
        }
        enum "strict-no-ecmp" {
          value 3;
        }
      }
      description "uRPF check mode type.";
    }

    typedef vas-if-type {
      type enumeration {
        enum "to-from-access" {
          value 1;
        }
        enum "to-from-network" {
          value 2;
        }
        enum "to-from-both" {
          value 3;
        }
      }
      description "Type of VAS interface.";
    }

    typedef lsr-load-balancing {
      type enumeration {
        enum "lbl-only" {
          value 1;
        }
        enum "lbl-ip" {
          value 2;
        }
        enum "ip-only" {
          value 3;
        }
        enum "eth-encap-ip" {
          value 4;
        }
        enum "lbl-ip-l4-teid" {
          value 5;
        }
      }
      description
        "Type of LSR load balancing algorithm type.";
    }

    typedef qos-route-lookup {
      type enumeration {
        enum "destination" {
          value 1;
        }
        enum "source" {
          value 2;
        }
      }
      description
        "Type of QoS route lookup.";
    }

    typedef qos-route-lookup-grp-if {
      type enumeration {
        enum "destination" {
          value 1;
        }
      }
      description
        "Type of QoS route lookup for group-interfaces.";
    }

    typedef ip-load-balancing {
      type enumeration {
        enum "both" {
          value 0;
        }
        enum "destination" {
          value 1;
        }
        enum "source" {
          value 2;
        }
        enum "inner-ip" {
          value 3;
        }
      }
      description
        "IP load balancing algorithm type.";
    }

    typedef dscp-app-name {
      type enumeration {
        enum "bgp" {
          value 1;
        }
        enum "cflowd" {
          value 2;
        }
        enum "dhcp" {
          value 3;
        }
        enum "dns" {
          value 4;
        }
        enum "ftp" {
          value 5;
        }
        enum "icmp" {
          value 6;
        }
        enum "igmp" {
          value 7;
        }
        enum "l2tp" {
          value 8;
        }
        enum "ldp" {
          value 9;
        }
        enum "mld" {
          value 10;
        }
        enum "msdp" {
          value 11;
        }
        enum "ndis" {
          value 12;
        }
        enum "ntp" {
          value 13;
        }
        enum "ospf" {
          value 14;
        }
        enum "pim" {
          value 15;
        }
        enum "radius" {
          value 16;
        }
        enum "rip" {
          value 17;
        }
        enum "rsvp" {
          value 18;
        }
        enum "snmp" {
          value 19;
        }
        enum "snmp-notification" {
          value 20;
        }
        enum "srrp" {
          value 21;
        }
        enum "ssh" {
          value 22;
        }
        enum "syslog" {
          value 23;
        }
        enum "tacplus" {
          value 24;
        }
        enum "telnet" {
          value 25;
        }
        enum "tftp" {
          value 26;
        }
        enum "traceroute" {
          value 27;
        }
        enum "vrrp" {
          value 28;
        }
        enum "ptp" {
          value 29;
        }
        enum "igmp-reporter" {
          value 30;
        }
        enum "gtp" {
          value 31;
        }
        enum "sflow" {
          value 34;
        }
        enum "diameter" {
          value 35;
        }
        enum "pcep" {
          value 36;
        }
        enum "call-trace" {
          value 37;
        }
        enum "bmp" {
          value 38;
        }
        enum "grpc" {
          value 39;
        }
        enum "mtrace2" {
          value 40;
        }
        enum "http" {
          value 41;
        }
        enum "mpls-udp-return" {
          value 42;
        }
        enum "pfcp" {
          value 43;
        }
        enum "ibcp" {
          value 44;
        }
      }
      description
        "DSCP Application identifiers for protocols that generate control
             traffic on the Nokia SROS router.";
    }

    typedef dscp-app-name-vprn {
      type enumeration {
        enum "bgp" {
          value 1;
        }
        enum "dhcp" {
          value 3;
        }
        enum "dns" {
          value 4;
        }
        enum "ftp" {
          value 5;
        }
        enum "icmp" {
          value 6;
        }
        enum "igmp" {
          value 7;
        }
        enum "l2tp" {
          value 8;
        }
        enum "ldp" {
          value 9;
        }
        enum "mld" {
          value 10;
        }
        enum "msdp" {
          value 11;
        }
        enum "ndis" {
          value 12;
        }
        enum "ntp" {
          value 13;
        }
        enum "ospf" {
          value 14;
        }
        enum "pim" {
          value 15;
        }
        enum "radius" {
          value 16;
        }
        enum "rip" {
          value 17;
        }
        enum "rsvp" {
          value 18;
        }
        enum "snmp" {
          value 19;
        }
        enum "snmp-notification" {
          value 20;
        }
        enum "srrp" {
          value 21;
        }
        enum "ssh" {
          value 22;
        }
        enum "syslog" {
          value 23;
        }
        enum "tacplus" {
          value 24;
        }
        enum "telnet" {
          value 25;
        }
        enum "tftp" {
          value 26;
        }
        enum "traceroute" {
          value 27;
        }
        enum "vrrp" {
          value 28;
        }
        enum "ptp" {
          value 29;
        }
        enum "gtp" {
          value 31;
        }
        enum "diameter" {
          value 35;
        }
        enum "pcep" {
          value 36;
        }
        enum "call-trace" {
          value 37;
        }
        enum "bmp" {
          value 38;
        }
        enum "grpc" {
          value 39;
        }
        enum "mtrace2" {
          value 40;
        }
        enum "http" {
          value 41;
        }
        enum "pfcp" {
          value 43;
        }
        enum "ibcp" {
          value 44;
        }
      }
      description
        "DSCP Application identifiers for protocols that generate control
             traffic on the Nokia SROS router.";
    }

    typedef dot1p-app-name {
      type enumeration {
        enum "arp" {
          value 1;
        }
        enum "isis" {
          value 2;
        }
        enum "pppoe" {
          value 3;
        }
      }
      description
        "IEEE 802.1p priority (Dot1p) Application identifiers for Layer-2
             protocols that generate control traffic on the Nokia
             SROS router.";
    }

    typedef vprn-ttl-propagate {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "all" {
          value 1;
        }
        enum "vc-only" {
          value 2;
        }
        enum "use-base" {
          value 3;
        }
      }
      description
        "Specifies whether or not to enable the propagation of
             time to live (TTL) at Ingress LER from the
             header of the IP packet into all labels in the stack.

             When the value is set to 'none' the IP TTL propagation is
             disabled from the IP header to all labels in the stack
             including the VC label.

             When the value is set to 'all' the IP TTL is propagated from the header
             of the IP packet into all labels in the stack.

             When the value is set to 'vc-only' the IP TTL is propagated from
             the IP header into the VC label but not the transport labels
             in the stack.

             When the value is set to 'use-base', the VPRN instance uses the
             base router instance configuration.";
    }

    typedef router-vprn-ttl-propagate {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "all" {
          value 1;
        }
        enum "vc-only" {
          value 2;
        }
      }
      description
        "Specifies whether or not to enable the propagation of
             time to live (TTL) at Ingress LER from the
             header of the IP packet into all labels in the stack.

             When the value is set to 'none' the IP TTL propagation is
             disabled from the IP header to all labels in the stack
             including the VC label.

             When the value is set to 'all' the IP TTL is propagated from the header
             of the IP packet into all labels in the stack.

             When the value is set to 'vc-only' the IP TTL is propagated from
             the IP header into the VC label but not the transport labels
             in the stack.";
    }

    typedef ttl-propagate-type {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "all" {
          value 1;
        }
      }
      description
        "Specifies whether or not to enable the propagation
             of time to live (TTL) from the header of IP packet
             into all labels in the stack.

             When the value is set to 'none' the IP TTL propagation is
             disabled from the IP header to all labels in the stack.

             When the value is set to 'all' the IP TTL is propagated from
             the header of the IP packet into all labels in the stack.";
    }

    typedef cflowd-sampling {
      type enumeration {
        enum "unicast" {
          value 1;
        }
        enum "multicast" {
          value 2;
        }
        enum "both" {
          value 3;
        }
      }
      description
        "The cflowd-parameters sampling type";
    }

    typedef unicast-multicast {
      type enumeration {
        enum "unicast" {
          value 1;
        }
        enum "multicast" {
          value 2;
        }
      }
      description
        "Specifies if unicast or multicast mode is used.";
    }

    typedef unicast-broadcast {
      type enumeration {
        enum "unicast" {
          value 1;
        }
        enum "broadcast" {
          value 2;
        }
      }
      description
        "Specifies if unicast or broadcast mode is used.";
    }

    typedef ipv4-tcp-mss {
      type uint32 {
        range "384..9158";
      }
      description
        "Specifies TCP maximum segment size for IPv4.";
    }

    typedef ipv4-tcp-mss-ext {
      type uint32 {
        range "384..9746";
      }
      description
        "Specifies TCP maximum segment size for IPv4 for increased port-mtu in fp4 cards.";
    }

    typedef ipv6-tcp-mss {
      type uint32 {
        range "1220..9138";
      }
      description
        "Specifies TCP maximum segment size for IPv6.";
    }

    typedef ipv6-tcp-mss-ext {
      type uint32 {
        range "1220..9726";
      }
      description
        "Specifies TCP maximum segment size for IPv6 for increased port-mtu in fp4 cards.";
    }

    typedef hold-time-seconds {
      type uint32 {
        range "1..1200";
      }
      description
        "Specifies the hold time in seconds.";
    }

    typedef ip-mtu {
      type uint32 {
        range "512..9000";
      }
      description
        "Specifies the IP MTU size.";
    }

    typedef ip-mtu-ext {
      type uint32 {
        range "512..9786";
      }
      description
        "Specifies the IP MTU size.";
    }

    typedef ldp-sync-timer {
      type uint32 {
        range "1..1800";
      }
      description
        "Specify LDP sync timer in seconds.";
    }

    typedef neighbor-discovery-stale-time {
      type uint32 {
        range "60..65535";
      }
      description
        "Specifies the time a neighbor discovery cache entry can remain
             stale before being removed.";
    }

    typedef neighbor-discovery-reachable-time {
      type uint32 {
        range "30..3600";
      }
      description
        "Configure neighbor reachability detection timer.";
    }

    typedef ipv4-neighbor-limit {
      type int32 {
        range "0..524288";
      }
      description
        "Specify the maximum amount of IPv4 ARP entries.";
    }

    typedef ipv6-neighbor-limit {
      type int32 {
        range "0..102400";
      }
      description
        "Specify the maximum amount of neigbhor entries.";
    }

    typedef ipv6-address-type-selection {
      type enumeration {
        enum "global" {
          value 1;
        }
        enum "link-local" {
          value 2;
        }
        enum "both" {
          value 3;
        }
      }
      description
        "Ipv6 address type selection.";
    }

    typedef router-port {
      type union {
        type types-sros:port-and-encap;
        type enumeration {
          enum "system" {
            value 1073741825;
          }
        }
      }
      description
        "Specify port/SAP for the network interface.";
    }

    typedef tunnel-type {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "invalid" {
          value 1;
        }
        enum "sdp" {
          value 2;
        }
        enum "rsvp" {
          value 3;
        }
        enum "ldp" {
          value 4;
        }
        enum "ospf" {
          value 5;
        }
        enum "isis" {
          value 6;
        }
        enum "bypass" {
          value 7;
        }
        enum "gre" {
          value 8;
        }
        enum "bgp" {
          value 9;
        }
        enum "sr-te" {
          value 10;
        }
        enum "fpe" {
          value 11;
        }
        enum "udp" {
          value 12;
        }
        enum "ospfv3" {
          value 13;
        }
        enum "mpls-fwd-policy" {
          value 14;
        }
        enum "sr-policy" {
          value 15;
        }
        enum "rib-api" {
          value 16;
        }
        enum "bgp-epe" {
          value 17;
        }
        enum "srv6-isis" {
          value 18;
        }
        enum "srv6-policy" {
          value 19;
        }
      }
      description
        "Indicates the type of a tunnel entity.";
    }

    typedef route-tag {
      type uint32 {
        range "1..255";
      }
      description
        "Specifies the route tag for ARP or neighbor discovery.";
    }

    typedef next-hop-type {
      type enumeration {
        enum "none" {
          value 0;
        }
        enum "has-lfa" {
          value 1;
        }
        enum "has-backup" {
          value 2;
        }
        enum "is-backup" {
          value 3;
        }
        enum "is-bgp-inactive" {
          value 4;
        }
        enum "is-lfa" {
          value 5;
        }
      }
      description
        "Indicates the properties of the tunnel next hop.";
    }

    typedef next-hop-flags {
      type bits {
        bit is-inactive {
          position 0;
        }
        bit is-backup {
          position 1;
        }
      }
      description
        "Bit flags that indicate additional properties of the next hop:
                         
             If the bit 'is-inactive' is set, this indicates the next hop is
             currently inactive.

             If the bit 'is-backup' is set, this indicates the next hop is a
             backup next hop. This next hop backs up another next hop that
             has the same next-hop group ID.";
    }

    typedef tunnel-flags {
      type bits {
        bit is-over-tunnel {
          position 0;
        }
        bit use-relative-metric {
          position 1;
        }
        bit auto-lsp {
          position 2;
        }
        bit has-lfa {
          position 3;
        }
        bit exclude-for-ldp-over-rsvp {
          position 4;
        }
        bit exclude-for-l3-vpn {
          position 5;
        }
        bit exclude-for-bgp-shortcuts {
          position 6;
        }
        bit exclude-for-bgp-labeled-routes {
          position 7;
        }
        bit exclude-for-lfa {
          position 8;
        }
        bit exclude-for-igp-shortcuts {
          position 9;
        }
        bit entropy-label-capable {
          position 10;
        }
        bit is-adjacency-tunnel {
          position 11;
        }
        bit lsp-bfd-down {
          position 12;
        }
        bit prefer-transport-frr {
          position 14;
        }
      }
      description
        "Indicates the following:

             If value of 'is-over-tunnel' is set, it indicates that this tunnel is
             over another tunnel.

             A value of 'use-relative-metric' indicates to use the relative metric info
             to offset IGP path cost to tunnel destination instead of absolute tunnel
             metric.

             A value of 'auto-lsp' indicates if the LSP is an automatic LSP.

             If value of 'has-lfa' is set, then this tunnel next-hop has a loop-free
             alternate hop.

             If value of 'exclude-for-ldp-over-rsvp' is set (applicable to RSVP tunnel
             only), then the MPLS LSP is not allowed to be used for LDP over RSVP.

             If value of 'exclude-for-l3-vpn' is set, it indicates not to use this
             tunnel for L3 VPNs.

             If value of 'exclude-for-bgp-shortcuts' is set, it indicates not to use
             this tunnel for BGP shortcuts.

             If value of 'exclude-for-bgp-labeled-routes' is set, it indicates not to use
             this tunnel for BGP labeled routes.

             If value of 'exclude-for-lfa' is set, it indicates not to use this tunnel
             for loop-free alternate.

             If value of 'exclude-for-igp-shortcuts' is set, it indicates not to use
             this tunnel for IGP shortcuts.

             If value of 'entropy-label-capable' is set, it indicates this tunnel is
             entropy capable.

             If value of 'is-adjacency-tunnel' is set, it indicates that this tunnel is
             a segment-routing adjacency tunnel.

             If value of 'lsp-bfd-down' is set, it indicates that BFD is down on this
             tunnel/FEC and that it will not be used as a transport tunnel. If this
             value is not set, then LSP-BFD is not configured on the tunnel/FEC, or
             LSP-BFD is configured and the BFD state is up.

             If value of 'prefer-transport-frr' is set, it indicates that this tunnel
             will defer to using any underlying transport tunnel's FRR.";
    }

    typedef tos-marking-state {
      type enumeration {
        enum "trusted" {
          value 1;
        }
        enum "untrusted" {
          value 2;
        }
      }
      description
        "Specifies the TOS marking state.";
    }

    typedef protocol-type {
      type enumeration {
        enum "other" {
          value 0;
        }
        enum "local" {
          value 1;
        }
        enum "host" {
          value 2;
        }
        enum "sub-mgmt" {
          value 3;
        }
        enum "managed" {
          value 4;
        }
        enum "static" {
          value 5;
        }
        enum "sdp" {
          value 6;
        }
        enum "rsvp" {
          value 7;
        }
        enum "ldp" {
          value 8;
        }
        enum "ospf" {
          value 9;
        }
        enum "ospfv3" {
          value 10;
        }
        enum "isis" {
          value 11;
        }
        enum "rip" {
          value 12;
        }
        enum "icmp" {
          value 13;
        }
        enum "aggregate" {
          value 14;
        }
        enum "bgp" {
          value 15;
        }
        enum "bgp-vpn" {
          value 16;
        }
        enum "mpls-bypass" {
          value 17;
        }
        enum "local-ipsec" {
          value 18;
        }
        enum "bgp-l2" {
          value 19;
        }
        enum "gre" {
          value 20;
        }
        enum "bgp-ttm" {
          value 21;
        }
        enum "local-bh" {
          value 22;
        }
        enum "nat" {
          value 23;
        }
        enum "vpn-leak" {
          value 24;
        }
        enum "tms" {
          value 25;
        }
        enum "ipreas" {
          value 26;
        }
        enum "mpls-tp" {
          value 27;
        }
        enum "mobile-host" {
          value 28;
        }
        enum "aaa" {
          value 29;
        }
        enum "dhcpv6-pd" {
          value 30;
        }
        enum "dhcpv6-pd-excl" {
          value 31;
        }
        enum "dhcpv6-na" {
          value 32;
        }
        enum "dhcpv6-ta" {
          value 33;
        }
        enum "ripng" {
          value 34;
        }
        enum "ipsec" {
          value 35;
        }
        enum "bgp-evpn" {
          value 36;
        }
        enum "sr-te" {
          value 37;
        }
        enum "bgp-label" {
          value 38;
        }
        enum "fpe" {
          value 39;
        }
        enum "udp" {
          value 40;
        }
        enum "arp-nd" {
          value 41;
        }
        enum "mpls-fwd-policy" {
          value 42;
        }
        enum "sr-policy" {
          value 43;
        }
        enum "rib-api" {
          value 44;
        }
        enum "dhcp-client" {
          value 45;
        }
        enum "nd-ra" {
          value 46;
        }
        enum "bgp-epe" {
          value 47;
        }
        enum "evpn-ifl" {
          value 48;
        }
        enum "evpn-iff" {
          value 49;
        }
        enum "srv6" {
          value 50;
        }
        enum "srv6-isis" {
          value 51;
        }
        enum "srv6-policy" {
          value 52;
        }
        enum "vxlan" {
          value 54;
        }
      }
      description "Route and tunnel owners.";
    }

    typedef nexthop-priority {
      type enumeration {
        enum "undefined" {
          value 0;
        }
        enum "low" {
          value 1;
        }
        enum "high" {
          value 2;
        }
      }
      description
        "The priority to apply to a packet.
             When set to undefined(0), the priority is not applicable.";
    }

    typedef interface-type {
      type enumeration {
        enum "network" {
          value 1;
        }
        enum "service" {
          value 2;
        }
        enum "service-ies" {
          value 3;
        }
        enum "service-rtd-vpls" {
          value 4;
        }
        enum "service-vprn" {
          value 5;
        }
        enum "service-ies-subscriber" {
          value 6;
        }
        enum "service-ies-group" {
          value 7;
        }
        enum "service-vprn-subscriber" {
          value 8;
        }
        enum "service-vprn-group" {
          value 9;
        }
        enum "service-ies-redundant" {
          value 10;
        }
        enum "service-vprn-redundant" {
          value 11;
        }
        enum "service-vpls" {
          value 12;
        }
        enum "service-ies-cem" {
          value 13;
        }
        enum "service-vprn-cem" {
          value 14;
        }
        enum "service-vprn-ipsec" {
          value 15;
        }
        enum "service-vprn-ip-mirror" {
          value 16;
        }
        enum "service-video" {
          value 17;
        }
        enum "service-vpls-video" {
          value 18;
        }
        enum "multi-homing-primary" {
          value 19;
        }
        enum "multi-homing-secondary" {
          value 20;
        }
        enum "service-ies-tunnel" {
          value 21;
        }
        enum "service-ip-reas" {
          value 22;
        }
        enum "network-ip-reas" {
          value 23;
        }
        enum "network-vprn" {
          value 24;
        }
        enum "reserved25" {
          value 25;
        }
        enum "service-ies-aarp" {
          value 26;
        }
        enum "service-vprn-aarp" {
          value 27;
        }
        enum "service-ies-aa" {
          value 28;
        }
        enum "service-vprn-aa" {
          value 29;
        }
        enum "unnum-mpls-tp" {
          value 30;
        }
        enum "gmpls-loopback" {
          value 31;
        }
        enum "control-tunnel" {
          value 32;
        }
        enum "pdn" {
          value 33;
        }
      }
      description "Type of interface.";
    }

    typedef pcep-capabilities {
      type enumeration {
        enum "stateful-delegate" {
          value 0;
        }
        enum "stateful-pce" {
          value 1;
        }
        enum "stateful-optimize" {
          value 2;
        }
        enum "segment-rt-path" {
          value 3;
        }
        enum "rsvp-path" {
          value 4;
        }
        enum "optice-gmpls" {
          value 5;
        }
        enum "pce-initiated-lsp" {
          value 6;
        }
        enum "stateless" {
          value 7;
        }
      }
      description
        "The value specifies the capabilities supported by PCEP";
    }

    typedef pcep-lsp-type {
      type enumeration {
        enum "rsvp-p2p" {
          value 1;
        }
        enum "rsvp-p2mp" {
          value 2;
        }
        enum "seg-rt" {
          value 3;
        }
        enum "pce-init-seg-rt" {
          value 4;
        }
      }
      description
        "The value specifies the type of LSP connection The valid options are:
             rsvp-p2p   (1) - Resource Reservation Protocol-Traffic Engineering
                    (RSVP-TE) Point to Point.
             rsvp-p2mp  (2) - RSVP-TE Point to Multipoint.
             seg-rt     (3) - Segment Routing.";
    }

    typedef metric-value {
      type enumeration {
        enum "igp-metric" {
          value 0;
        }
        enum "te-metric" {
          value 1;
        }
        enum "hop-count" {
          value 2;
        }
      }
      description
        "The value specifies the METRIC object used in PCReq message ";
    }

    typedef pcep-sync-state {
      type enumeration {
        enum "not-initialized" {
          value 0;
        }
        enum "in-progress" {
          value 1;
        }
        enum "done" {
          value 2;
        }
      }
      description
        "The value of indicates the synchronization
             state of this peer. The valid options are:
             notInitialized (0) - Indicates the State Synchronization has not
             yet started or not initialized due to no
             connection with the peer.
             in-progress    (1) - Indicates the State Synchronization is in progress
             done           (2) - Indicates the State Synchronozation has been completed.";
    }

    typedef router-id {
      type types-sros:ipv4-address;
      description "Specifies the router-id.";
    }

    typedef selective-ilm-default-forwarding {
      type enumeration {
        enum "forward" {
          value 0;
        }
        enum "drop" {
          value 1;
        }
      }
      description
        "The value specifies the default action for selective ILM (Incoming Label Map).";
    }

    typedef flex-algo-id {
      type uint32 {
        range "128..255";
      }
      description "Flexible Algorithm ID";
    }

    typedef pce-id {
      type uint32 {
        range "1..4294967295";
      }
      description
        "The value specifies a unique PCE-specific identifier.";
    }
  }  // module nokia-types-router