ietf-te.yang

module ietf-te {
  yang-version 1.1;

  namespace "urn:ietf:params:xml:ns:yang:ietf-te";

  /* Replace with IANA when assigned */
  prefix "te";

  /* Import TE generic types */
  import ietf-te-types {
    prefix te-types;
  }

  import ietf-inet-types {
    prefix inet;
  }

  organization
    "IETF Traffic Engineering Architecture and Signaling (TEAS)
     Working Group";

  contact
    "WG Web:   <http://tools.ietf.org/wg/teas/>
     WG List:  <mailto:teas@ietf.org>

     WG Chair: Lou Berger
               <mailto:lberger@labn.net>

     WG Chair: Vishnu Pavan Beeram
               <mailto:vbeeram@juniper.net>

     Editor:   Tarek Saad
               <mailto:tsaad@cisco.com>

     Editor:   Rakesh Gandhi
               <mailto:rgandhi@cisco.com>

     Editor:   Vishnu Pavan Beeram
               <mailto:vbeeram@juniper.net>

     Editor:   Himanshu Shah
               <mailto:hshah@ciena.com>

     Editor:   Xufeng Liu
               <mailto:Xufeng_Liu@jabil.com>

     Editor:   Igor Bryskin
               <mailto:Igor.Bryskin@huawei.com>";

  description
    "YANG data module for TE configuration,
    state, RPC and notifications.";

  revision "2017-07-02" {
    description "Latest update to TE generic YANG module.";
    reference "TBA";
  }

  typedef tunnel-ref {
    type leafref {
      path "/te:te/te:tunnels/te:tunnel/te:name";
    }
    description
      "This type is used by data models that need to reference
       configured TE tunnel.";
  }

  typedef tunnel-p2mp-ref {
    type leafref {
      path "/te:te/te:tunnels/te:tunnel-p2mp/te:name";
    }
    description
      "This type is used by data models that need to reference
       configured P2MP TE tunnel.";
  }

  /**
   * TE tunnel generic groupings
   */
  grouping path-route-objects {
    description
      "List of EROs to be included or excluded when performing
       the path computation.";
    container explicit-route-objects {
      description
        "Container for the exclude route object list";
      list route-object-exclude-always {
        key index;
        description
          "List of explicit route objects to always exclude
           from path computation";
        leaf index {
          type leafref {
            path "../config/index";
          }
          description
            "Index of this explicit route object";
        }
        uses te-types:explicit-route-hop;
      }
      list route-object-include-exclude {
        key index;
        description
          "List of explicit route objects to include or
           exclude in path computation";
        leaf index {
          type leafref {
            path "../config/index";
          }
          description
            "Index of this explicit route object";
        }
        leaf explicit-route-usage {
          type identityref {
            base te-types:route-usage-type;
          }
          description "Explicit-route usage.";
        }
        uses te-types:explicit-route-hop;
      }
    }
  }

  grouping path-affinities-contents_config {
    description
      "Path affinities constraints grouping";
    leaf usage {
      type identityref {
        base te-types:resource-affinities-type;
      }
      description "Affinities usage";
    }
    choice style {
      description
        "Path affinities representation style";
      case value {
        leaf value {
          type te-types:admin-groups;
          description
            "Bitmap indicating what bits are of significance";
        }
      }
      case named {
        list affinity-names {
          key "name";
          leaf name {
            type string;
            description "Affinity name";
          }
          description
            "List of named affinities";
        }
      }
    }
  }

  grouping path-affinities {
    description
      "Path affinities grouping";
    container path-affinities {
      description
        "Path affinities container";
      list constraints {
        key "usage";
        description
          "List of named affinity constraints";
        leaf usage {
          type leafref {
            path "../config/usage";
          }
          description "Affinities usage";
        }
        container config {
          description
            "Configuration intended parameters";
          uses path-affinities-contents_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses path-affinities-contents_config;
        }
      }
    }
  }

  grouping path-affinities-values_config {
    description
      "Path affinities values configuration grouping";
    leaf usage {
      type identityref {
        base te-types:route-exclude-srlg;
      }
      description "SRLG usage";
    }
    leaf-list values {
      type te-types:srlg;
      description "SRLG value";
    }
  }

  grouping path-srlgs {
    description
      "Path SRLG properties grouping";
    container path-srlgs {
      description
        "Path SRLG properties container";
      choice style {
        description
          "Type of SRLG representation";
        case values {
          container config {
            description
              "Configuration intended parameters";
            uses path-affinities-values_config;
          }
          container state {
            config false;
            description
              "Configuration applied parameters and state";
            uses path-affinities-values_config;
          }
        }
        case named {
          list constraints {
            key "usage";
            leaf usage {
              type leafref {
                path "../config/usage";
              }
              description "Affinity resource usage";
            }
            container config {
              description
                "Configuration intended parameters";
              leaf usage {
                type identityref {
                  base te-types:route-exclude-srlg;
                }
                description "SRLG usage";
              }
            }
            container state {
              config false;
              description
                "Configuration applied parameters and state";
              leaf usage {
                type identityref {
                  base te-types:route-exclude-srlg;
                }
                description "SRLG usage";
              }
            }
            container constraint {
              description
                "Container for named SRLG list";
              list srlg-names {
                key "name";
                leaf name {
                  type leafref  {
                    path "../config/name";
                  }
                  description "The SRLG name";
                }
                container config {
                  description
                    "Configuration intended parameters";
                  leaf name {
                    type string;
                    description "The SRLG name";
                  }
                }
                container state {
                  config false;
                  description
                    "Configuration applied parameters and
                     state";
                  leaf name {
                    type string;
                    description "The SRLG name";
                  }
                }
                description "List named SRLGs";
              }
            }
            description
              "List of named SRLG constraints";
          }
        }
      }
    }
  }

  grouping bidir-assoc-properties {
    description
      "TE tunnel associated bidirectional properties
      grouping";
    container bidirectional {
      description
        "TE tunnel associated bidirectional attributes.";
      container association {
        description
          "Tunnel bidirectional association properties";
        leaf id {
          type uint16;
          description
            "The TE tunnel association identifier.";
        }
        leaf source {
          type inet:ip-address;
          description
            "The TE tunnel association source.";
        }
        leaf global-source {
          type inet:ip-address;
          description
            "The TE tunnel association global
            source.";
        }
        leaf type {
          type identityref {
            base te-types:bidir-association-type;
          }
          default te-types:bidir-assoc-non-corouted;
          description
            "The TE tunnel association type.";
        }
        leaf provisioing {
          type identityref {
            base te-types:bidir-provisioning-mode;
          }
          description
            "Describes the provisioning model of the
            associated bidirectional LSP";
          reference
            "draft-ietf-teas-mpls-tp-rsvpte-ext-
            associated-lsp, section-3.2";
        }
      }
    }
  }

  grouping p2p-secondary-path-properties {
    description
      "tunnel path properties.";
    container config {
      description
        "Configuration intended parameters";
      uses p2p-path-properties_config;
    }
    container state {
      config false;
      description
        "Configuration applied parameters and state";
      uses p2p-path-properties_config;
      uses p2p-path-properties_state;
    }
  }

  grouping p2p-primary-path-properties {
    description
      "TE tunnel primary path properties grouping";
    uses hierarchical-link;
    container config {
      description
        "Configuration intended parameters";
      uses p2p-path-properties_config;
    }
    container state {
      config false;
      description
        "Configuration applied parameters and state";
      uses p2p-path-properties_config;
      uses p2p-path-properties_state;
    }
  }

  grouping computed-path-properties_state {
    description "TE computed path properties grouping";
    container computed-path-properties {
      description "The TE path computed properties";
      list path-metric {
        key metric-type;
        description "TE path metric type";
        leaf metric-type {
          type identityref {
            base te-types:path-metric-type;
          }
          description "TE path metric type";
        }
        leaf accumulative-value {
          type uint64;
          description "TE path metric accumulative value";
        }
      }
      uses path-affinities;
      uses path-srlgs;
      container path-computed-route-objects {
        description
          "Container for the list of computed route objects
           as returned by the computation engine";
        list path-computed-route-object {
          key index;
          description
            "List of computed route objects returned by the
             computation engine";
          uses te-types:explicit-route-hop_config;
        }
      }
    }
  }

  grouping p2p-path-properties_state {
    description "TE per path state parameters";
    container lsps {
      description "TE LSPs container";
      list lsp {
        key
          "source destination tunnel-id lsp-id "+
          "extended-tunnel-id";
        description "List of LSPs associated with the tunnel.";
        uses computed-path-properties_state;
        uses lsp-properties_state;
      }
    }
  }

  grouping p2p-path-properties_config {
    description
      "TE tunnel path properties configuration grouping";
    leaf name {
      type string;
      description "TE path name";
    }
    leaf preference {
      type uint8 {
        range "1..255";
      }
      description
        "Specifies a preference for this path. The lower the
        number higher the preference";
    }
    leaf path-setup-protocol {
      type identityref {
        base te-types:te-path-setup-protocol;
      }
      description
        "Signaling protocol used to set up this tunnel";
    }
    leaf path-computation-method {
      type identityref {
        base te-types:path-computation-method;
      }
      default te-types:path-locally-computed;
      description
        "The method used for computing the path, either
        locally computed, queried from a server or not
        computed at all (explicitly configured).";
    }
    leaf path-computation-server {
      when "../path-computation-method = "+
      "'te-types:path-externally-queried'" {
        description
          "The path-computation server when the path is
           externally queried";
      }
      type inet:ip-address;
      description
        "Address of the external path computation
         server";
    }
    leaf compute-only {
      type empty;
      description
        "When set, the path is computed and updated whenever
         the topology is updated. No resources are committed
         or reserved in the network.";
    }
    leaf use-path-computation {
      when "../path-computation-method =" +
      " 'te-types:path-locally-computed'";
      type boolean;
      description "A CSPF dynamically computed path";
    }
    leaf verbatim {
      type empty;
      description
        "Indicates no topology or CSPF is attempted on the
         specified path.";
    }
    leaf lockdown {
      type empty;
      description
        "Indicates no reoptimization to be attempted for
         this path.";
    }
    leaf named-explicit-path {
      when "../path-computation-method =" +
      " 'te-types:path-explicitly-defined'";
      type leafref {
        path "../../../../../../globals/named-explicit-paths/"
        + "named-explicit-path/config/name";
      }
      description "The explicit-path name";
    }
    leaf named-path-constraint {
      if-feature te-types:named-path-constraints;
      type leafref {
        path "../../../../../../globals/"
        + "named-path-constraints/named-path-constraint/"
        + "config/name";
      }
      description
        "Reference to a globally defined named path
        constraint set";
    }
  }

  /* TE tunnel configuration data */
  grouping tunnel-p2mp-params_config {
    description
      "Configuration parameters relating to TE tunnel";
    leaf name {
      type string;
      description "TE tunnel name.";
    }
    leaf type {
      type identityref {
        base te-types:tunnel-type;
      }
      description "TE tunnel type.";
    }
    leaf identifier {
      type uint16;
      description
        "TE tunnel Identifier.";
    }
    leaf description {
      type string;
      description
        "Textual description for this TE tunnel";
    }
    leaf bandwidth-generic {
      type te-types:te-bandwidth;
      description
        "A technology agnostic requested bandwidth to use
         for path computation";
    }
    leaf setup-priority {
      type uint8 {
        range "0..7";
      }
      description
        "TE LSP setup priority";
    }
    leaf hold-priority {
      type uint8 {
        range "0..7";
      }
      description
        "TE LSP hold priority";
    }
    leaf lsp-protection-type {
      type identityref {
        base te-types:lsp-prot-type;
      }
      description "LSP protection type.";
    }

    leaf admin-status {
      type identityref {
        base te-types:tunnel-admin-state-type;
      }
      default te-types:tunnel-admin-state-up;
      description "TE tunnel administrative state.";
    }

    leaf reoptimize-timer {
      type uint16;
      units seconds;
      description
       "frequency of reoptimization of
        a traffic engineered LSP";
    }
  }

  grouping hierarchical-link_config {
    description
      "Hierarchical link configuration grouping";
    leaf local-te-node-id {
      type te-types:te-node-id;
      description
        "Local TE node identifier";
    }
    leaf local-te-link-tp-id {
      type te-types:te-tp-id;
      description
        "Local TE link termination point identifier";
    }
    leaf remote-te-node-id {
      type te-types:te-node-id;
      description
        "Remote TE node identifier";
    }
    leaf te-topology-id {
      type te-types:te-topology-id;
      description
        "It is presumed that a datastore will contain many
         topologies. To distinguish between topologies it is
         vital to have UNIQUE topology identifiers.";
    }
  }

  grouping hierarchical-link {
    description
      "Hierarchical link grouping";
    container hierarchical-link {
      description
        "Identifies a hierarchical link (in client layer)
         that this tunnel is associated with.";
      container config {
        description
          "Configuration intended parameters";
        uses hierarchical-link_config;
      }
      container state {
        config false;
        description
          "Configuration applied parameters and state";
        uses hierarchical-link_config;
      }
    }
  }

  grouping tunnel-p2p-params_config {
    description
      "Configuration parameters relating to TE tunnel";
    leaf name {
      type string;
      description "TE tunnel name.";
    }
    leaf type {
      type identityref {
        base te-types:tunnel-type;
      }
      description "TE tunnel type.";
    }
    leaf identifier {
      type uint16;
      description
        "TE tunnel Identifier.";
    }
    leaf description {
      type string;
      description
        "Textual description for this TE tunnel";
    }
    leaf encoding {
      type identityref {
        base te-types:lsp-encoding-types;
      }
      description "LSP encoding type";
    }
    leaf switching-type {
      type identityref {
        base te-types:switching-capabilities;
      }
      description "LSP switching type";
      reference "RFC3945";
    }
    leaf protection-type {
      type identityref {
        base te-types:lsp-prot-type;
      }
      description "LSP protection type.";
    }
    leaf provisioning-state {
      type identityref {
        base te-types:tunnel-state-type;
      }
      default te-types:tunnel-state-up;
      description "TE tunnel administrative state.";
    }
    leaf preference {
      type uint8 {
        range "1..255";
      }
      description
        "Specifies a preference for this tunnel.
        A lower number signifies a better preference";
    }
    leaf reoptimize-timer {
      type uint16;
      units seconds;
      description
       "frequency of reoptimization of
        a traffic engineered LSP";
    }
    leaf source {
      type inet:ip-address;
      description
        "TE tunnel source address.";
    }
    leaf destination {
      /* Add when check */
      type inet:ip-address;
      description
        "P2P tunnel destination address";
    }
    leaf src-tp-id {
      type binary;
      description
        "TE tunnel source termination point identifier.";
    }
    leaf dst-tp-id {
      /* Add when check */
      type binary;
      description
        "TE tunnel destination termination point identifier.";
    }
    uses common-constraints_config;
    uses bidir-assoc-properties;
  }

  grouping tunnel-p2p-params_state {
    description
      "State parameters relating to TE tunnel";
    leaf operational-state {
      type identityref {
        base te-types:tunnel-state-type;
      }
      default te-types:tunnel-state-up;
      description "TE tunnel administrative state.";
    }
    container dependency-tunnels {
      description "Dependency tunnels list";
      list dependency-tunnel {
        key "name";
        description "Dependency tunnel entry";
        leaf name {
          type leafref {
            path "../../../../../../tunnels/tunnel/name";
          }
          description "Dependency tunnel name";
        }
        leaf encoding {
          type identityref {
            base te-types:lsp-encoding-types;
          }
          description "LSP encoding type";
        }
        leaf switching-type {
          type identityref {
            base te-types:switching-capabilities;
          }
          description "LSP switching type";
          reference "RFC3945";
        }
      }
    }
  }

  grouping access-segment-info {
    description
      "info related to a segment";
    container forward {
      description
        "for the forward direction of this tunnel";
      container config {
        description
          "Configuration intended parameters";
        uses te-types:label-set-info;
      }
      container state {
        config false;
        description
          "Configuration applied parameters and state";
        uses te-types:label-set-info;
      }
    }
    container reverse {
      description
        "for the reverse direction of this tunnel";
      container config {
        description
          "Configuration intended parameters";
        uses te-types:label-set-info;
      }
      container state {
        config false;
        description
          "Configuration applied parameters and state";
        uses te-types:label-set-info;
      }
    }
  }

  grouping path-access-segment-info {
    description
      "If an end-to-end tunnel crosses multiple domains using
       the same technology, some additional constraints have to be
       taken in consideration in each domain";
    // the name as in ietf-mpls-static
    container in-segment {
      presence
        "The end-to-end tunnel starts in a previous domain;
         this tunnel is a segment in the current domain.";
      description
        "This tunnel is a segment that needs to be coordinated
         with previous segment stitched on head-end side.";
      uses access-segment-info;
    }
    container out-segment {
      presence
        "The end-to-end tunnel is not terminated in this domain;
         this tunnel is a segment in the current domain.";
      description
        "This tunnel is a segment that needs to be coordinated
         with previous segment stitched on head-end side.";
      uses access-segment-info;
    }
  }

  /* TE tunnel configuration/state grouping */
  grouping tunnel-p2mp-properties {
    description
      "Top level grouping for P2MP tunnel properties.";
    container config {
      description
        "Configuration intended parameters";
      uses tunnel-p2mp-params_config;
    }
    container state {
      config false;
      description
        "Configuration applied parameters and state";
      leaf operational-state {
        type identityref {
          base te-types:tunnel-state-type;
        }
        default te-types:tunnel-state-up;
        description "TE tunnel administrative state.";
      }
      uses tunnel-p2mp-params_config;
    }
  }

  grouping p2p-path-candidate-secondary-path-config {
    description
      "Configuration parameters relating to a secondary path which
      is a candidate for a particular primary path";

    leaf secondary-path {
      type leafref {
        path "../../../../../../p2p-secondary-paths/" +
             "p2p-secondary-path/config/name";
      }
      description
        "A reference to the secondary path that should be utilised
        when the containing primary path option is in use";
    }

    leaf priority {
      type uint16;
      description
        "The priority of the specified secondary path option. Higher
        priority options are less preferable - such that a secondary
        path reference with a priority of 0 is the most preferred";
    }
    leaf path-setup-protocol {
      type identityref {
        base te-types:te-path-setup-protocol;
      }
      description
        "Signaling protocol used to set up this tunnel";
    }
  }

  grouping p2p-path-candidate-secondary-path-state {
    description
      "Operational state parameters relating to a secondary path
      which is a candidate for a particular primary path";

    leaf active {
      type boolean;
      description
        "Indicates the current active path option that has
        been selected of the candidate secondary paths";
    }
  }

  grouping tunnel-p2p-properties {
    description
      "Top level grouping for tunnel properties.";
    container config {
      description
        "Configuration intended parameters";
      uses tunnel-p2p-params_config;
    }
    container state {
      config false;
      description
        "Configuration applied parameters and state";
      uses tunnel-p2p-params_config;
      uses tunnel-p2p-params_state;
    }

    container p2p-primary-paths {
      description "Set of P2P primary aths container";
      list p2p-primary-path {
        key "name";
        description
          "List of primary paths for this tunnel.";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "TE path name";
        }
        uses p2p-primary-path-properties;
        container candidate-p2p-secondary-paths {
          description
            "The set of candidate secondary paths which may be used
            for this primary path. When secondary paths are specified
            in the list the path of the secondary LSP in use must be
            restricted to those path options referenced. The
            priority of the secondary paths is specified within the
            list. Higher priority values are less preferred - that is
            to say that a path with priority 0 is the most preferred
            path. In the case that the list is empty, any secondary
            path option may be utilised when the current primary path
            is in use.";
          list candidate-p2p-secondary-path {
            key "secondary-path";
            description
              "List of secondary paths for this tunnel.";
            leaf secondary-path {
              type leafref {
                path "../config/secondary-path";
              }
              description "TE path name";
            }
            container config {
              description
                "Configuration intended parameters";
              uses p2p-path-candidate-secondary-path-config;
            }

            container state {
              config false;
              description
                "Configuration applied parameters and state";
              uses p2p-path-candidate-secondary-path-config;
              uses p2p-path-candidate-secondary-path-state;
            }
          }
        }
      }
    }
    container p2p-secondary-paths {
      description "Set of P2P secondary paths container";
      list p2p-secondary-path {
        key "name";
        description
          "List of secondary paths for this tunnel.";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "TE path name";
        }
        uses p2p-primary-path-properties;
      }
    }
  }

  grouping tunnel-actions {
    description "Tunnel actions";
    action tunnel-action {
      description "Tunnel action";
      input {
        leaf action-type {
          type identityref {
            base te-types:tunnel-action-type;
          }
          description "Tunnel action type";
        }
      }
      output {
        leaf action-result {
          type identityref {
            base te-types:te-action-result;
          }
          description "The result of the RPC operation";
        }
      }
    }
  }
  /*** End of TE tunnel groupings ***/

  /**
   * LSP related generic groupings
   */
  grouping lsp-record-route-information_state {
    description "recorded route information grouping";
    container lsp-record-route-subobjects {
      description "RSVP recorded route object information";
      list record-route-subobject {
        when "../../origin-type = 'ingress'" {
          description "Applicable on non-ingress LSPs only";
        }
        key "index";
        description "Record route sub-object list";
        leaf index {
          type uint32;
          description "RRO subobject index";
        }
        uses te-types:record-route-subobject;
      }
    }
  }

  grouping lsps-state-grouping {
    description
      "LSPs state operational data grouping";
    container lsps-state {
      config false;
      description "TE LSPs state container";
      list lsp {
        key
          "source destination tunnel-id lsp-id "+
          "extended-tunnel-id";
        description "List of LSPs associated with the tunnel.";
        uses lsp-properties_state;
      }
    }
  }

  /*** End of TE LSP groupings ***/

  /**
   * TE global generic groupings
   */

  /* Global named admin-groups configuration data */
  grouping named-admin-groups_config {
    description
      "Global named administrative groups configuration
      grouping";
    leaf name {
      type string;
      description
        "A string name that uniquely identifies a TE
        interface named admin-group";
    }
    leaf bit-position {
      type uint32;
      description
        "Bit position representing the administrative group";
    }
  }
  grouping named-admin-groups {
    description
      "Global named administrative groups configuration
      grouping";
    container named-admin-groups {
      description "TE named admin groups container";
      list named-admin-group {
        if-feature te-types:extended-admin-groups;
        if-feature te-types:named-extended-admin-groups;
        key "name";
        description
          "List of named TE admin-groups";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "Admin-group name";
        }
        container config {
          description
            "Configuration intended parameters";
          uses named-admin-groups_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses named-admin-groups_config;
        }
      }
    }
  }

  /* Global named admin-srlgs configuration data */
  grouping named-srlgs_config {
    description
      "Global named SRLGs configuration grouping";
    leaf name {
      type string;
      description
        "A string name that uniquely identifies a TE
        interface named srlg";
    }
    leaf group {
      type te-types:srlg;
      description "An SRLG value";
    }
    leaf cost {
      type uint32;
      description
        "SRLG associated cost. Used during path to append
         the path cost when traversing a link with this SRLG";
    }
  }

  grouping named-srlgs {
    description
      "Global named SRLGs configuration grouping";
    container named-srlgs {
      description "TE named SRLGs container";
      list named-srlg {
        if-feature te-types:named-srlg-groups;
        key "name";
        description
          "A list of named SRLG groups";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "SRLG name";
        }
        container config {
          description
            "Configuration intended parameters";
          uses named-srlgs_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses named-srlgs_config;
        }
      }
    }
  }

  /* Global named explicit-paths configuration data */
  grouping named-explicit-paths_config {
    description
      "Global explicit path configuration
      grouping";
    leaf name {
      type string;
      description
        "A string name that uniquely identifies an
        explicit path";
    }
  }

  grouping named-explicit-paths {
    description
      "Global explicit path configuration
      grouping";
    container named-explicit-paths {
      description "TE named explicit path container";
      list named-explicit-path {
        key "name";
        description
          "A list of explicit paths";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "Explicit-path name";
        }
        container config {
          description
            "Configuration intended parameters";
          uses named-explicit-paths_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses named-explicit-paths_config;
        }
        container explicit-route-objects {
          description "Explicit route objects container";
          list explicit-route-object {
            key "index";
            description
              "List of explicit route objects";
            leaf index {
              type leafref {
                path "../config/index";
              }
              description
                "Index of this explicit route object";
            }
            leaf explicit-route-usage {
              type identityref {
                base te-types:route-usage-type;
              }
              description "An explicit-route hop action.";
            }
            uses te-types:explicit-route-hop;
          }
        }
      }
    }
  }

  /* Global named paths constraints configuration data */
  grouping path-metrics-bounds_config {
    description "TE path metric bounds grouping";
    leaf metric-type {
      type identityref {
        base te-types:path-metric-type;
      }
      description "TE path metric type";
    }
    leaf upper-bound {
      type uint64;
      description "Upper bound on end-to-end TE path metric";
    }
  }

  grouping path-objective-function_config {
    description "Optimization metrics configuration grouping";
    leaf objective-function-type {
      type identityref {
        base te-types:objective-function-type;
      }
      description
        "Objective function entry";
    }
  }


  grouping path-objective-function {
    description "Objective functions grouping";

    /* Optimize by metric */
    container optimizations {
      description
        "The objective function container that includes
         attributes to impose when computing a TE path";
      list optimization-metric {
        key "metric-type";
        description "TE path metric type";
        leaf metric-type {
          type leafref {
            path "../config/metric-type";
          }
          description
            "Optimization metric type";
        }
        container config {
          description
            "Configuration intended parameters";
          uses te-types:optimizations_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses te-types:optimizations_config;
        }
      }
    }

    /* Objective functions */
    container path-objective-function {
      description
        "The objective function container that includes
         attributes to impose when computing a TE path";
      container config {
        description
          "Configuration intended parameters";
        uses path-objective-function_config;
      }
      container state {
        config false;
        description
          "Configuration applied parameters and state";
        uses path-objective-function_config;
      }
    }

    /* Tiebreakers */
    container tiebreakers {
      description
        "The list of tiebreaker criterion to apply
         on an equally favored set of paths to pick best";
      list tiebreaker {
        key "tiebreaker-type";
        description
          "The list of tiebreaker criterion to apply
           on an equally favored set of paths to pick best";
        leaf tiebreaker-type {
          type leafref {
            path "../config/tiebreaker-type";
          }
          description "The tiebreaker type";
        }
        container config {
          description
            "Configuration intended parameters";
          leaf tiebreaker-type {
            type identityref {
              base te-types:path-metric-type;
            }
            description "The objective function";
          }
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          leaf tiebreaker-type {
            type identityref {
              base te-types:path-metric-type;
            }
            description "The objective function";
          }
        }
      }
    }
  }

  grouping path-metric-bounds {
    description "TE path metric bounds grouping";
    container path-metric-bounds {
      description "TE path metric bounds container";
      list path-metric-bound {
        key metric-type;
        description "List of TE path metrics";
        leaf metric-type {
          type leafref {
            path "../config/metric-type";
          }
          description
            "The TE path metric type";
        }
        container config {
          description
            "Configuration intended parameters";
          uses path-metrics-bounds_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses path-metrics-bounds_config;
        }
      }
    }
  }

  grouping path-constraints_state {
    description
      "TE path constraints state";
    leaf bandwidth-generic_state {
      type te-types:te-bandwidth;
      description
        "A technology agnostic requested bandwidth to use
         for path computation";
    }
    leaf disjointness_state {
      type te-types:te-path-disjointness;
      description
        "The type of resource disjointness.";
    }
  }

  grouping common-constraints_config {
    description
      "Common constraints grouping that can be set on
       a constraint set or directly on the tunnel";
    leaf topology-id {
      type te-types:te-topology-id;
      description
        "The tunnel path is computed using the specific
        topology identified by this identifier";
    }
    leaf ignore-overload {
      type boolean;
      description
        "The tunnel path can traverse overloaded node.";
    }
    leaf bandwidth-generic {
      type te-types:te-bandwidth;
      description
        "A technology agnostic requested bandwidth to use
         for path computation";
    }
    leaf disjointness {
      type te-types:te-path-disjointness;
      description
        "The type of resource disjointness.";
    }
    leaf setup-priority {
      type uint8 {
        range "0..7";
      }
      description
        "TE LSP requested setup priority";
    }
    leaf hold-priority {
      type uint8 {
        range "0..7";
      }
      description
        "TE LSP requested hold priority";
    }
    leaf signaling-type {
      type identityref {
        base te-types:path-signaling-type;
      }
      description "TE tunnel path signaling type";
    }
  }

  grouping named-path-constraints_config {
    description
      "Global named path constraints configuration
      grouping";
    leaf name {
      type string;
      description
        "A string name that uniquely identifies a
        path constraint set";
    }
    uses common-constraints_config;
    uses path-affinities;
    uses path-srlgs;
  }

  grouping named-path-constraints {
    description
      "Global named path constraints configuration
      grouping";
    container named-path-constraints {
      description "TE named path constraints container";
      list named-path-constraint {
        if-feature te-types:named-path-constraints;
        key "name";
        description
          "A list of named path constraints";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "Path constraint name";
        }
        uses path-metric-bounds;
        container config {
          description
            "Configuration intended parameters";
          uses named-path-constraints_config;
        }
        container state {
          config false;
          description
            "Configuration applied parameters and state";
          uses named-path-constraints_config;
          uses path-constraints_state;
        }
        uses path-route-objects;
        uses path-objective-function;
        uses path-access-segment-info {
          description
            "Tunnel constraints induced by other segments.";
        }
      }
    }
  }

  /* TE globals container data */
  grouping globals-grouping {
    description
      "Globals TE system-wide configuration data grouping";
    container globals {
      description
        "Globals TE system-wide configuration data container";
      uses named-admin-groups;
      uses named-srlgs;
      uses named-explicit-paths;
      uses named-path-constraints;
    }
  }

  /* TE tunnels container data */
  grouping tunnels-grouping {
    description
      "Tunnels TE configuration data grouping";
    container tunnels {
      description
        "Tunnels TE configuration data container";

      list tunnel {
        key "name";
        description "P2P TE tunnels list.";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "TE tunnel name.";
        }
        leaf identifier {
          type leafref {
            path "../config/identifier";
          }
          description
            "TE tunnel Identifier.";
        }
        uses tunnel-p2p-properties;
        uses tunnel-actions;
      }
      list tunnel-p2mp {
        key "name";
        unique "identifier";
        description "P2MP TE tunnels list.";
        leaf name {
          type leafref {
            path "../config/name";
          }
          description "TE tunnel name.";
        }
        leaf identifier {
          type leafref {
            path "../config/identifier";
          }
          description
            "TE tunnel Identifier.";
        }
        uses tunnel-p2mp-properties;
      }
    }
  }

  /* TE LSPs ephemeral state container data */
  grouping lsp-properties_state {
    description
      "LSPs state operational data grouping";
    leaf source {
      type inet:ip-address;
      description
        "Tunnel sender address extracted from
        SENDER_TEMPLATE  object";
      reference "RFC3209";
    }
    leaf destination {
      type inet:ip-address;
      description
        "Tunnel endpoint address extracted from
        SESSION object";
      reference "RFC3209";
    }
    leaf tunnel-id {
      type uint16;
      description
        "Tunnel identifier used in the SESSION
        that remains constant over the life
        of the tunnel.";
      reference "RFC3209";
    }
    leaf lsp-id {
      type uint16;
      description
        "Identifier used in the SENDER_TEMPLATE
        and the FILTER_SPEC that can be changed
        to allow a sender to share resources with
        itself.";
      reference "RFC3209";
    }
    leaf extended-tunnel-id {
      type inet:ip-address;
       description
        "Extended Tunnel ID of the LSP.";
      reference "RFC3209";
    }
    leaf operational-state {
      type identityref {
        base te-types:lsp-state-type;
      }
      description "LSP operational state.";
    }
    leaf path-setup-protocol {
      type identityref {
        base te-types:te-path-setup-protocol;
      }
      description
        "Signaling protocol used to set up this tunnel";
    }
    leaf origin-type {
      type enumeration {
        enum ingress {
          description
            "Origin ingress";
        }
        enum egress {
          description
            "Origin egress";
        }
        enum transit {
          description
            "transit";
        }
      }
      description
        "Origin type of LSP relative to the location
        of the local switch in the path.";
    }

    leaf lsp-resource-status {
      type enumeration {
        enum primary {
          description
            "A primary LSP is a fully established LSP for
             which the resource allocation has been committed
             at the data plane";
        }
        enum secondary {
          description
            "A secondary LSP is an LSP that has been provisioned
             in the control plane only; e.g. resource allocation
             has not been committed at the data plane";
        }
      }
      description "LSP resource allocation type";
      reference "rfc4872, section 4.2.1";
    }

    leaf lsp-protection-role {
      type enumeration {
        enum working {
          description
            "A working LSP must be a primary LSP whilst a protecting
             LSP can be either a primary or a secondary LSP. Also,
             known as protected LSPs when working LSPs are associated
             with protecting LSPs.";
        }
        enum protecting {
          description
            "A secondary LSP is an LSP that has been provisioned
             in the control plane only; e.g. resource allocation
             has not been committed at the data plane";
        }
      }
      description "LSP role type";
      reference "rfc4872, section 4.2.1";
    }

    leaf lsp-carry-normal-traffic {
      type empty;
      description
        "This bit is set when a protecting LSP is carrying the normal
         traffic after protection switching";
    }
    uses lsp-record-route-information_state;
  }
  /*** End of TE global groupings ***/

  /**
   * TE configurations container
   */
  container te {
    presence "Enable TE feature.";
    description
       "TE global container.";

    /* TE Global Configuration Data */
    uses globals-grouping;

    /* TE Tunnel Configuration Data */
    uses tunnels-grouping;

    /* TE LSPs State Data */
    uses lsps-state-grouping;
  }

  /* TE Global RPCs/execution Data */
  rpc globals-rpc {
    description
      "Execution data for TE global.";
  }

  /* TE interfaces RPCs/execution Data */
  rpc interfaces-rpc {
    description
      "Execution data for TE interfaces.";
  }

  /* TE Tunnel RPCs/execution Data */
  rpc tunnels-rpc {
    description "TE tunnels RPC nodes";
    input {
      container tunnel-info {
        description "Tunnel Identification";
        choice type {
          description "Tunnel information type";
          case tunnel-p2p {
            leaf p2p-id {
              type te:tunnel-ref;
              description "P2P TE tunnel";
            }
          }
          case tunnel-p2mp {
            leaf p2mp-id {
              type te:tunnel-p2mp-ref;
              description "P2MP TE tunnel";
            }
          }
        }
      }
    }
    output {
      container result {
        description
          "The container result of the RPC operation";
        leaf result {
          type enumeration {
            enum success {
              description "Origin ingress";
            }
            enum in-progress {
              description "Origin egress";
            }
            enum fail {
              description "transit";
            }
          }
          description "The result of the RPC operation";
        }
      }
    }
  }

  /* TE Global Notification Data */
  notification globals-notif {
    description
      "Notification messages for Global TE.";
  }

  /* TE Tunnel Notification Data */
  notification tunnels-notif {
    description
      "Notification messages for TE tunnels.";
  }
}