module Cisco-IOS-XR-infra-xtc-cfg {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-infra-xtc-cfg";

    prefix infra-xtc-cfg;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR infra-xtc package configuration.
     
     This module contains definitions
     for the following management objects:
       pce: PCE configuration data
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-03-03" {
      description
        "Added PCE API address configuration
       2021-02-17
         Removing the hop-type key leaf from path-info list
       2021-01-12
         srv6 global msd config.
       2021-01-06
         schema changes of removing srv6 explicit bsid cfg.
       2020-11-20
         Adding leaf to enable Anycast SID inclusion for all SR policies
       2020-11-14
         Added P2MP policy fast reroute support Changed Cleanup timer range change Added Support for invalidation drop and protected/unprotected path
       2020-08-07
         Adding configurations for new features path invalidation drop protected and unprotected path
       2020-07-07
         Added PCE global constraint bounds latency configuration.";
    }

    revision "2020-06-25" {
      description
        "Added API VRF config
       2020-06-14
       Added SR native CSPF algorithm configuration
       2020-06-11
       REST API interface in VRF config.
       2020-03-31
       Hidde PM DM liveness and named profile for 721.
       2020-02-21
       Adding disjointness-status leaf to logging container to support logging of messages whenever disjointness status changes.
       2020-02-11
       Removing enable leafs from submodes. Added sid-limit leaf for SID limit configuration.
       2019-11-17
       Adding leaf exclude-srlg to support SR-PCE srlg-exclude with disjointness.
       2019-10-09
       Adding container constraints to suppport Flex-algo related info.
       2019-09-25
       Adding enum ipv4-adjacency-address, leaf adjacency-address, leaf address-type, leaf interface-identifier, leaf prefix-length, and leaf validate-flag to support SRV6.";
    }

    revision "2019-09-24" {
      description
        "Add submode-enter enable leaf to segment-list container.";
    }

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2018-07-25" {
      description
        "Removed incorrect mandatory specifications.";
    }

    revision "2018-07-02" {
      description
        "Removed mandatory specification from Netconf SSH username/password";
    }

    revision "2017-09-30" {
      description
        "Ensure propagation of MDA mandatory state to YANG model.";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2016-05-31" {
      description
        "Revision description string.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "3.0.0";
    semver:module-version "2.0.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Pce-loggging-disabled {
      type enumeration {
        enum "disabled" {
          value 1;
          description "Logging disabled";
        }
      }
      description "Pce loggging disabled";
    }

    typedef Pce-segment {
      type enumeration {
        enum "ipv4-address" {
          value 1;
          description "IPv4 Address";
        }
        enum "mpls-label" {
          value 3;
          description "MPLS Label";
        }
        enum "ipv4-adjacency-address" {
          value 4;
          description
            "IPv4 Adjacency Address";
        }
      }
      description "Pce segment";
    }

    typedef Pce-tree-sid {
      type enumeration {
        enum "mpls-label" {
          value 1;
          description "MPLS Label";
        }
      }
      description "Pce tree sid";
    }

    typedef Pcep2mp-fast-reroute {
      type enumeration {
        enum "lfa" {
          value 1;
          description "LFA Fast Re-route";
        }
      }
      description "Pcep2mp fast reroute";
    }

    typedef Pce-bound-scope {
      type enumeration {
        enum "bound-scope-none" {
          value 0;
          description "BOUND SCOPE NONE";
        }
        enum "bound-scope-cumulative" {
          value 2;
          description
            "bounds on path metric";
        }
      }
      description "Pce bound scope";
    }

    typedef Pce-append-sid {
      type enumeration {
        enum "mpls-label" {
          value 1;
          description "MPLS Label";
        }
      }
      description "Pce append sid";
    }

    typedef Pce-api-authentication {
      type enumeration {
        enum "digest" {
          value 2;
          description "MD5-Digest HTTP auth";
        }
      }
      description "Pce api authentication";
    }

    typedef Pce-cumulative-metric {
      type enumeration {
        enum "latency" {
          value 12;
          description "Latency metric type";
        }
      }
      description "Pce cumulative metric";
    }

    typedef Xtc-adj-sid-protection {
      type enumeration {
        enum "protected-preferred" {
          value 0;
          description
            "Protected adj SID preferred";
        }
        enum "unprotected-only" {
          value 1;
          description
            "Unprotected adj SID only";
        }
        enum "protected-only" {
          value 2;
          description
            "Protected adj SID only";
        }
        enum "unprotected-preferred" {
          value 3;
          description
            "Unprotected adj SID preferred";
        }
      }
      description "Xtc adj sid protection";
    }

    typedef Pce-path-hop {
      type enumeration {
        enum "mpls" {
          value 1;
          description "Segment-routing MPLS";
        }
        enum "srv6" {
          value 2;
          description "Segment-routing v6";
        }
      }
      description "Pce path hop";
    }

    typedef Pce-path {
      type enumeration {
        enum "explicit" {
          value 1;
          description "Explicit";
        }
        enum "dynamic" {
          value 2;
          description "Dynamic";
        }
      }
      description "Pce path";
    }

    typedef Pce-disjoint-path {
      type enumeration {
        enum "link" {
          value 1;
          description "Link";
        }
        enum "node" {
          value 2;
          description "Node";
        }
        enum "srlg" {
          value 3;
          description "SRLG";
        }
        enum "srlg-node" {
          value 4;
          description "SRLG Node";
        }
      }
      description "Pce disjoint path";
    }

    typedef Pce-end-point {
      type enumeration {
        enum "end-point-type-ipv4" {
          value 1;
          description
            "IPv4 endpoint address";
        }
        enum "end-point-type-ipv6" {
          value 2;
          description
            "IPv6 endpoint address";
        }
      }
      description "Pce end point";
    }

    typedef Pce-binding-sid {
      type enumeration {
        enum "mpls-label-specified" {
          value 1;
          description
            "Use specified BSID MPLS label";
        }
        enum "mpls-label-any" {
          value 2;
          description
            "Allocate BSID MPLS label";
        }
      }
      description "Pce binding sid";
    }

    typedef Pce-metric {
      type enumeration {
        enum "igp" {
          value 1;
          description "IGP metric type";
        }
        enum "te" {
          value 2;
          description "TE metric type";
        }
        enum "hopcount" {
          value 3;
          description "Hopcount metric type";
        }
        enum "latency" {
          value 12;
          description "Latency metric type";
        }
      }
      description "Pce metric";
    }

    typedef Pce-address-family {
      type enumeration {
        enum "af-type-ipv4" {
          value 1;
          description "IPv4 address family";
        }
        enum "af-type-ipv6" {
          value 2;
          description "IPv6 address family";
        }
      }
      description "Pce address family";
    }

    typedef Pce-path-selection {
      type enumeration {
        enum "protected" {
          value 0;
          description "protected";
        }
        enum "unprotected" {
          value 1;
          description "unprotected";
        }
      }
      description "Pce path selection";
    }

    grouping SHUTDOWN {
      description
        "Common node of p2mp-policy, policy";
      leaf shutdown {
        type empty;
        description
          "Administratively shutdown policy";
      }
    }  // grouping SHUTDOWN

    grouping METRIC {
      description
        "Common node of path-info, p2mp-path-info";
      container metric {
        presence
          "CLI submode compatibility.";
        description
          "Metric configuration, valid only for dynamic
         path-options";
        leaf metric-type {
          type Pce-metric;
          description "Metric type";
        }

        leaf sid-limit {
          type uint32 {
            range "1..255";
          }
          description "SID limit value";
        }

        leaf enable {
          type empty;
          description "True only";
        }
      }  // container metric
    }  // grouping METRIC

    grouping CONSTRAINTS {
      description
        "Common node of preference, pce";
      container constraints {
        description
          "SR path computation and verification constraints";
        container bounds {
          description
            "Bound related configuration";
          container bounds {
            description
              "Path computation and verification metric
             bounds";
            list bound {
              key "scope-type metric-type";
              description
                "Path computation and verification metric
               bound";
              leaf scope-type {
                type Pce-bound-scope;
                description
                  "Scope of the bound";
              }

              leaf metric-type {
                type Pce-cumulative-metric;
                description
                  "Metric type to bound";
              }

              leaf bound-value {
                type uint32 {
                  range "1..4294967295";
                }
                mandatory true;
                description
                  "Metric Bound Value";
              }
            }  // list bound
          }  // container bounds
        }  // container bounds

        container segment-rules {
          description
            "SR path computation segment specific rules";
          leaf protection-type {
            type Xtc-adj-sid-protection;
            description "Protection Type";
          }

          leaf sid-algorithm {
            type uint32 {
              range "128..255";
            }
            description
              "Prefix-SID algorithm";
          }
        }  // container segment-rules
      }  // container constraints
    }  // grouping CONSTRAINTS

    grouping P2MPFRR-NODE-SET-ADDRESS-TABLE {
      description
        "Common node of p2mpfrr-node-set-from,
       p2mpfrr-node-set-to";
      container p2mpfrr-node-set-addresses {
        description
          "P2MP frr-node-set address table";
        list p2mpfrr-node-set-address {
          key "af-type endpoint-address";
          description
            "P2MP frr-node-set address configuration";
          leaf af-type {
            type Pce-address-family;
            description
              "FRR node address-family type";
          }

          leaf endpoint-address {
            type inet:ip-address-no-zone;
            description "FRR node address";
          }
        }  // list p2mpfrr-node-set-address
      }  // container p2mpfrr-node-set-addresses
    }  // grouping P2MPFRR-NODE-SET-ADDRESS-TABLE

    grouping AFFINITY-RULE-TABLE {
      description
        "Common node of candidate-paths, p2mp-constraints";
      container affinity-rules {
        description "Affinity rule table";
        list affinity-rule {
          key "rule aff-value";
          description "Affinity rule";
          leaf rule {
            type uint32 {
              range "0..2";
            }
            description "affinity rule";
          }

          leaf aff-value {
            type xr:Cisco-ios-xr-string {
              length "1..32";
            }
            description "affinity value";
          }
        }  // list affinity-rule
      }  // container affinity-rules
    }  // grouping AFFINITY-RULE-TABLE

    container pce {
      presence "CLI submode compatibility.";
      description "PCE configuration data";
      container authentication-option {
        presence
          "Indicates a authentication-option node is configured.";
        description
          "Configure global AO keychain based
         authentication";
        leaf keychain {
          type string {
            length "1..32";
          }
          mandatory true;
          description "Name of the keychain";
        }

        leaf include-tcp-options {
          type boolean;
          description
            "Include other TCP options in the header";
        }

        leaf accept-mismatch-connection {
          type boolean;
          description
            "Accept new connection even if Authentication
           Option mismatched";
        }
      }  // container authentication-option

      container ipv6-state-syncs {
        description
          "Standby IPv6 PCE configuration";
        list ipv6-state-sync {
          key "address";
          description
            "Standby PCE ipv6 address";
          leaf address {
            type inet:ipv6-address-no-zone;
            description "IPv6 address";
          }
        }  // list ipv6-state-sync
      }  // container ipv6-state-syncs

      container pcc-addresses {
        description
          "Path computation client configuration";
        list pcc-address {
          key "address";
          description
            "Path computation client address";
          container lsp-names {
            description
              "MPLS label switched path";
            list lsp-name {
              key "name";
              description
                "MPLS label switched path";
              container rsvp-te {
                presence
                  "CLI submode compatibility.";
                description
                  "RSVP-TE configuration";
                container affinity {
                  description "LSP Affinity";
                  leaf include-any {
                    type xr:Hex-integer;
                    description
                      "Include-any affinity value";
                  }

                  leaf include-all {
                    type xr:Hex-integer;
                    description
                      "Include-all affinity value";
                  }

                  leaf exclude-any {
                    type xr:Hex-integer;
                    description
                      "Exclude-any affinity value";
                  }
                }  // container affinity

                container priority {
                  presence
                    "Indicates a priority node is configured.";
                  description
                    "Tunnel Setup and Hold Priorities";
                  leaf setup-priority {
                    type uint32 {
                      range "0..7";
                    }
                    mandatory true;
                    description
                      "Setup Priority";
                  }

                  leaf hold-priority {
                    type uint32 {
                      range "0..7";
                    }
                    mandatory true;
                    description
                      "Hold Priority";
                  }
                }  // container priority

                leaf fast-protect {
                  type empty;
                  description
                    "Enable fast protection";
                }

                leaf bandwidth {
                  type uint32;
                  units "kbit/s";
                  mandatory true;
                  description
                    "Bandwidth configuration";
                }
              }  // container rsvp-te

              leaf undelegate {
                type empty;
                description "Undelegate LSP";
              }

              leaf explicit-path-name {
                type string;
                mandatory true;
                description
                  "Explicit-path name";
              }

              leaf name {
                type xr:Cisco-ios-xr-string;
                description "LSP name";
              }
            }  // list lsp-name
          }  // container lsp-names

          leaf address {
            type inet:ipv4-address-no-zone;
            description "IPv4 address";
          }
        }  // list pcc-address
      }  // container pcc-addresses

      container logging {
        description
          "PCE logging configuration";
        container rest-logging {
          description
            "REST logging configuration";
          leaf send-queue-congestion {
            type Pce-loggging-disabled;
            description
              "Logging of send queue congestion messages";
          }
        }  // container rest-logging

        leaf no-path {
          type empty;
          description
            "Logging NO-PATH configuration";
        }

        leaf pcerr {
          type empty;
          description
            "Logging of received PCErr messages";
        }

        leaf fallback {
          type empty;
          description
            "Logging fallback configuration";
        }

        leaf disjointness-status {
          type empty;
          description
            "Logging of disjointness status related messages";
        }
      }  // container logging

      container backoff {
        presence
          "Indicates a backoff node is configured.";
        description
          "PCE backoff configuration";
        leaf ratio {
          type uint32 {
            range "0..255";
          }
          default "2";
          description
            "Backoff common ratio configuration";
        }

        leaf threshold {
          type uint32 {
            range "0..3600";
          }
          default "0";
          description
            "Backoff threshold configuration";
        }

        leaf difference {
          type uint32 {
            range "0..255";
          }
          default "2";
          description
            "Backoff common difference configuration";
        }
      }  // container backoff

      container trace-counts {
        description
          "Configure PCE trace options";
        list trace-count {
          key "buffer-name";
          description
            "Trace count for provided buffer";
          leaf buffer-name {
            type xr:Cisco-ios-xr-string {
              length "1..15";
            }
            description "Buffer name";
          }

          leaf trace-count {
            type uint32 {
              range "0..1000000";
            }
            mandatory true;
            description "Trace count";
          }
        }  // list trace-count
      }  // container trace-counts

      container pce-peers {
        description "PCE peer configuration";
        list pce-peer {
          key "af-type pce-address";
          description "PCE peer";
          container authentication-option {
            presence
              "Indicates a authentication-option node is configured.";
            description
              "Configure Peer AO keychain based
             authentication";
            leaf keychain {
              type string {
                length "1..32";
              }
              mandatory true;
              description
                "Name of the keychain";
            }

            leaf include-tcp-options {
              type boolean;
              description
                "Include other TCP options in the header";
            }

            leaf accept-mismatch-connection {
              type boolean;
              description
                "Accept new connection even if Authentication
               Option mismatched";
            }
          }  // container authentication-option

          leaf password {
            type xr:Proprietary-password;
            description
              "PCE Peer MD5 Password";
          }

          leaf af-type {
            type Pce-address-family;
            description
              "Peer address-family type";
          }

          leaf pce-address {
            type inet:ip-address-no-zone;
            description "Remote PCE address";
          }
        }  // list pce-peer
      }  // container pce-peers

      container hierarchical {
        presence
          "CLI submode compatibility.";
        description
          "Configure hierarchical policy computation";
        container underlay {
          presence
            "CLI submode compatibility.";
          description
            "Configure underlay tunnels";
          leaf enable-all {
            type empty;
            description
              "Use all available tunnels as underlay";
          }
        }  // container underlay
      }  // container hierarchical

      container api {
        presence
          "CLI submode compatibility.";
        description
          "Northbound API configuration";
        container api-ipv6 {
          description
            "IPv6 API configuration";
          leaf api-ipv6-address {
            type inet:ipv6-address-no-zone;
            description
              "IPv6 address of API server";
          }
        }  // container api-ipv6

        container api-ipv4 {
          description
            "IPv4 API configuration";
          leaf api-ipv4-address {
            type inet:ipv4-address-no-zone;
            description
              "IPv4 address of API server";
          }
        }  // container api-ipv4

        container api-users {
          description
            "Northbound API authorized users configuration";
          list api-user {
            key "name";
            description
              "API authorized user";
            leaf api-user-password {
              type xr:Proprietary-password;
              description
                "API user password configuration";
            }

            leaf name {
              type xr:Cisco-ios-xr-string;
              description "User name";
            }
          }  // list api-user
        }  // container api-users

        leaf sibling {
          type inet:ip-address-no-zone;
          description
            "Address of sibling PCE";
        }

        leaf api-authentication {
          type Pce-api-authentication;
          description
            "API authentication type";
        }

        leaf api-vrf {
          type xr:Cisco-ios-xr-string {
            length "1..33";
          }
          description
            "API Interface vrf configuration";
        }
      }  // container api

      container state-syncs {
        description
          "Standby IPv4 PCE configuration";
        list state-sync {
          key "address";
          description
            "Standby PCE ipv4 address";
          leaf address {
            type inet:ipv4-address-no-zone;
            description "IPv4 address";
          }
        }  // list state-sync
      }  // container state-syncs

      container segment-routing {
        description
          "PCE segment-routing configuration";
        container traffic-engineering {
          presence
            "CLI submode compatibility.";
          description
            "Traffic Engineering configuration data";
          container affinity-bits {
            description "Affinity Bit-map";
            list affinity-bit {
              key "color-name";
              description "Affinity Bit";
              leaf color-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "Color Name";
              }

              leaf bit {
                type uint32 {
                  range "0..255";
                }
                mandatory true;
                description "The bit";
              }
            }  // list affinity-bit
          }  // container affinity-bits

          container peers {
            description "Peer configuration";
            list peer {
              key "peer-addr";
              description
                "Peer configuration";
              container policies {
                description
                  "Policy configuration";
                list policy {
                  key "policy-name";
                  description
                    "Policy configuration";
                  container binding-sid {
                    description
                      "Binding Segment ID";
                    leaf binding-sid-type {
                      type Pce-binding-sid;
                      description
                        "Binding SID type";
                    }

                    leaf mpls-label {
                      when
                        "../binding-sid-type = 'mpls-label-specified'" {
                        description
                          "../BindingSIDType = MPLSLabelSpecified";
                      }
                      type uint32 {
                        range "16..1048575";
                      }
                      description
                        "MPLS Label";
                    }
                  }  // container binding-sid

                  container color-endpoint {
                    description
                      "Color and Endpoint";
                    leaf color {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description "Color";
                    }

                    leaf end-point-type {
                      type Pce-end-point;
                      description
                        "End point type";
                    }

                    leaf end-point-address {
                      type inet:ip-address-no-zone;
                      description
                        "End point address";
                    }
                  }  // container color-endpoint

                  container candidate-paths {
                    presence
                      "CLI submode compatibility.";
                    description
                      "Policy candidate-paths configuration";
                    container append-sid {
                      description
                        "Append a specific SID to the computed
                       label stack";
                      leaf append-sid-type {
                        type Pce-append-sid;
                        description
                          "AppendSID type";
                      }

                      leaf mpls-label {
                        when
                          "../append-sid-type = 'mpls-label'" {
                          description
                            "../AppendSIDType = MPLSLabel";
                        }
                        type uint32 {
                          range "1..1048575";
                        }
                        description
                          "MPLS Label";
                      }
                    }  // container append-sid

                    container preferences {
                      description
                        "Policy path-option preference table";
                      list preference {
                        key "path-index";
                        description
                          "Policy path-option preference entry";
                        container path-infos {
                          description
                            "Policy path-option preference
                           configuration";
                          list path-info {
                            key "type hop-type segment-list-name";
                            description
                              "Policy configuration";
                            leaf type {
                              type Pce-path;
                              description
                                "Path-option type";
                            }

                            leaf hop-type {
                              type Pce-path-hop;
                              description
                                "Type of dynamic path to be computed";
                            }

                            leaf segment-list-name {
                              type xr:Cisco-ios-xr-string {
                                length
                                  "1..128";
                              }
                              description
                                "Segment-list name";
                            }

                            uses METRIC;
                          }  // list path-info
                        }  // container path-infos

                        leaf path-index {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "Path-option preference";
                        }

                        uses CONSTRAINTS;
                      }  // list preference
                    }  // container preferences

                    uses AFFINITY-RULE-TABLE;
                  }  // container candidate-paths

                  leaf profile-id {
                    type uint32 {
                      range "1..65534";
                    }
                    description
                      "Profile-ID to send to the PCC";
                  }

                  leaf path-selection {
                    type Pce-path-selection;
                    description
                      "Path selection type";
                  }

                  leaf policy-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..128";
                    }
                    description
                      "Policy name";
                  }

                  uses SHUTDOWN;
                }  // list policy
              }  // container policies

              leaf peer-addr {
                type inet:ip-address-no-zone;
                description "Peer address";
              }
            }  // list peer
          }  // container peers

          container cspf {
            description
              "Path computation configuration";
            container anycast-sid-inclusion {
              presence
                "CLI submode compatibility.";
              description
                "Enable Anycast SID Inclusion for all policies";
            }  // container anycast-sid-inclusion

            container sr-native {
              presence
                "CLI submode compatibility.";
              description
                "Use SR native algorithm";
              leaf force {
                type empty;
                description
                  "Use algorithm for all path computation";
              }
            }  // container sr-native
          }  // container cspf

          container p2mp {
            description "P2MP configuration";
            container p2mp-label-range {
              presence
                "Indicates a p2mp-label-range node is configured.";
              description
                "Specify label range for dynamic P2MP policies";
              leaf minimum {
                type uint32 {
                  range "16..1048575";
                }
                mandatory true;
                description
                  "Minimum value of label range";
              }

              leaf maximum {
                type uint32 {
                  range "16..1048575";
                }
                mandatory true;
                description
                  "Maximum value of label range";
              }
            }  // container p2mp-label-range

            container p2mp-policies {
              description
                "P2MP policy configuration";
              list p2mp-policy {
                key "policy-name";
                description
                  "P2MP policy configuration";
                container p2mp-color-endpoint-set {
                  description
                    "Color and endpoint-set";
                  leaf color {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description "Color";
                  }

                  leaf endpoint-set-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..128";
                    }
                    description
                      "Endpoint set name";
                  }
                }  // container p2mp-color-endpoint-set

                container p2mp-source {
                  description
                    "Source address";
                  leaf af-type {
                    type Pce-address-family;
                    description
                      "Address-family type";
                  }

                  leaf source-address {
                    type inet:ip-address-no-zone;
                    description
                      "Source IP address";
                  }
                }  // container p2mp-source

                container p2m-ptree-sid {
                  description
                    "TreeSID value";
                  leaf tree-sid {
                    type Pce-tree-sid;
                    description
                      "TreeSID type";
                  }

                  leaf mpls-label {
                    when
                      "../tree-sid = 'mpls-label'" {
                      description
                        "../TreeSID = MPLSLabel";
                    }
                    type uint32 {
                      range "16..1048575";
                    }
                    description "MPLS Label";
                  }
                }  // container p2m-ptree-sid

                container p2mp-candidate-paths {
                  description
                    "Policy candidate-paths configuration";
                  container p2mp-preferences {
                    description
                      "Policy path-option preference table";
                    list p2mp-preference {
                      key "path-index";
                      description
                        "Policy path-option preference entry";
                      container p2mp-path-infos {
                        description
                          "Policy path-option preference
                         configuration";
                        list p2mp-path-info {
                          key "type hop-type segment-list-name";
                          description
                            "Policy configuration";
                          leaf type {
                            type Pce-path;
                            description
                              "Path-option type";
                          }

                          leaf hop-type {
                            type Pce-path-hop;
                            description
                              "Type of dynamic path to be computed";
                          }

                          leaf segment-list-name {
                            type xr:Cisco-ios-xr-string {
                              length
                                "1..128";
                            }
                            description
                              "Segment-list name";
                          }

                          uses METRIC;
                        }  // list p2mp-path-info
                      }  // container p2mp-path-infos

                      leaf path-index {
                        type uint32 {
                          range "100";
                        }
                        description
                          "Path-option preference";
                      }
                    }  // list p2mp-preference
                  }  // container p2mp-preferences

                  container p2mp-constraints {
                    description
                      "Policy path contraints configuration";
                    uses AFFINITY-RULE-TABLE;
                  }  // container p2mp-constraints
                }  // container p2mp-candidate-paths

                leaf p2mp-policy-fast-reroute {
                  type Pcep2mp-fast-reroute;
                  description
                    "Enable Fast Re-route protection for this
                   tree";
                }

                leaf policy-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..128";
                  }
                  description "Policy name";
                }

                uses SHUTDOWN;
              }  // list p2mp-policy
            }  // container p2mp-policies

            container p2mpfrr-node-set-from {
              presence
                "CLI submode compatibility.";
              description
                "Nodes from which adjacencies are to be
               protected";
              uses P2MPFRR-NODE-SET-ADDRESS-TABLE;
            }  // container p2mpfrr-node-set-from

            container p2mpfrr-node-set-to {
              presence
                "CLI submode compatibility.";
              description
                "Nodes to which adjacencies are to be
               protected";
              uses P2MPFRR-NODE-SET-ADDRESS-TABLE;
            }  // container p2mpfrr-node-set-to

            container p2mp-endpoint-sets {
              description
                "P2MP endpoint-set table";
              list p2mp-endpoint-set {
                key "endpoint-set-name";
                description
                  "P2MP endpoint-set configuration";
                container p2mp-endpoint-set-addresses {
                  description
                    "P2MP endpoint-set address table";
                  list p2mp-endpoint-set-address {
                    key "af-type endpoint-address";
                    description
                      "P2MP endpoint-set address configuration";
                    leaf af-type {
                      type Pce-address-family;
                      description
                        "Endpoint address-family type";
                    }

                    leaf endpoint-address {
                      type inet:ip-address-no-zone;
                      description
                        "Endpoint address";
                    }
                  }  // list p2mp-endpoint-set-address
                }  // container p2mp-endpoint-set-addresses

                leaf endpoint-set-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..128";
                  }
                  description
                    "Endpoint set name";
                }
              }  // list p2mp-endpoint-set
            }  // container p2mp-endpoint-sets

            container p2mp-timers {
              description
                "P2MP timers configuration";
              leaf p2mp-timers-cleanup {
                type uint32 {
                  range "1..86400";
                }
                units "second";
                description
                  "Delay before node is excluded from P2MP path
                 computation after PCEP connection with it
                 goes away";
              }

              leaf p2mp-timers-reoptimization {
                type uint32 {
                  range "60..3600";
                }
                units "second";
                description
                  "How often to reoptimize all P2MP paths";
              }
            }  // container p2mp-timers

            leaf p2mp-fast-reroute {
              type Pcep2mp-fast-reroute;
              description
                "Enable Fast Re-route protection for all trees";
            }

            leaf p2mp-multipath-disable {
              type empty;
              description
                "Disable load balancing of SR P2MP across ECMP
               paths";
            }
          }  // container p2mp

          container segments {
            description
              "Segment-lists configuration";
            list segment {
              key "path-name";
              description
                "Segment-list configuration";
              container segments {
                description
                  "Segments/hops configuration for given
                 Segment-list";
                list segment {
                  key "segment-index";
                  description
                    "Configure Segment/hop at the index";
                  leaf segment-index {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Segment index";
                  }

                  leaf segment-type {
                    type Pce-segment;
                    description
                      "Segment/hop type";
                  }

                  leaf address {
                    when
                      "../segment-type = 'ipv4-address' or ../segment-type = 'ipv4-adjacency-address'" {
                      description
                        "../SegmentType = IPv4Address or .
                       ./SegmentType = IPv4AdjacencyAddress";
                    }
                    type inet:ipv4-address-no-zone;
                    description
                      "IPv4 Address";
                  }

                  leaf mpls-label {
                    when
                      "../segment-type = 'mpls-label'" {
                      description
                        "../SegmentType = MPLSLabel";
                    }
                    type uint32 {
                      range "0..1048575";
                    }
                    description "MPLS Label";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address-no-zone;
                    description
                      "IPv4 Adjacency Address";
                  }

                  leaf address-type {
                    when
                      "../segment-type = 'ipv4-adjacency-address'" {
                      description
                        "../SegmentType = IPv4AdjacencyAddress";
                    }
                    type uint32 {
                      range "0..32";
                    }
                    description
                      "IP address types";
                  }

                  leaf interface-identifier {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Interface Identifier";
                  }

                  leaf prefix-length {
                    type uint32 {
                      range "0..32";
                    }
                    description
                      "Prefix Length";
                  }

                  leaf validate-flag {
                    type uint32 {
                      range "0..1";
                    }
                    description
                      "Validate No Validate";
                  }
                }  // list segment
              }  // container segments

              leaf path-name {
                type xr:Cisco-ios-xr-string {
                  length "1..128";
                }
                description
                  "Segment-list name";
              }
            }  // list segment
          }  // container segments
        }  // container traffic-engineering

        leaf strict-sid-only {
          type empty;
          description
            "Use strict-sid-only configuration";
        }
      }  // container segment-routing

      container timers {
        presence
          "Indicates a timers node is configured.";
        description
          "PCE Timers configuration";
        leaf initial-verify-restart {
          type uint32 {
            range "10..10000";
          }
          units "second";
          default "40";
          description
            "Timer to wait for topology convergence after
           topology starts populating for restart case";
        }

        leaf peer-zombie {
          type uint32 {
            range "0..3600";
          }
          units "second";
          default "60";
          description
            "Timer value in seconds 0-3600. Use 0 to disable
           . Default is 60.";
        }

        leaf initial-verify-startup {
          type uint32 {
            range "10..10000";
          }
          units "second";
          default "120";
          description
            "Timer to wait for topology convergence after
           topology starts populating for startup case";
        }

        leaf reoptimization-timer {
          type uint32 {
            range "600..86400";
          }
          units "second";
          default "1800";
          description
            "Topology reoptimization timer configuration";
        }

        leaf initial-verify-switchover {
          type uint32 {
            range "10..10000";
          }
          units "second";
          default "60";
          description
            "Timer to wait for topology convergence after
           topology starts populating for switchover case";
        }

        leaf keepalive {
          type uint32 {
            range "0..255";
          }
          units "second";
          default "30";
          description
            "Keepalive interval in seconds, zero to disable";
        }

        leaf minimum-peer-keepalive {
          type uint32 {
            range "0..255";
          }
          units "second";
          default "20";
          description
            "Minimum acceptable peer proposed keepalive
           interval";
        }
      }  // container timers

      container netconf {
        presence
          "CLI submode compatibility.";
        description "NETCONF configuration";
        container netconf-ssh {
          description
            "NETCONF SSH configuration";
          leaf netconf-ssh-password {
            type xr:Proprietary-password;
            description
              "Password to use for NETCONF SSH connections";
          }

          leaf netconf-ssh-user {
            type string;
            description
              "User name to use for NETCONF SSH connections";
          }
        }  // container netconf-ssh
      }  // container netconf

      container disjoint-path {
        presence
          "CLI submode compatibility.";
        description
          "Disjoint path configuration";
        container groups {
          description
            "Association configuration";
          list group {
            key "group-id dp-type sub-id";
            description
              "Association Group Configuration";
            container group-lsp-records {
              description
                "lsp pcc records container with in group";
              list group-lsp-record {
                key "lsp-id";
                description
                  "LSP first/second PCC record tuple
                 containingIpAddr, LspName, DisjPath";
                leaf lsp-id {
                  type uint32 {
                    range "1..2";
                  }
                  description "Lsp id";
                }

                leaf ip-addr {
                  type inet:ipv4-address-no-zone;
                  description
                    "IP address of PCC";
                }

                leaf lsp-name {
                  type string;
                  description
                    "Identifying name for LSP";
                }

                leaf disj-path {
                  type uint32 {
                    range "0..1";
                  }
                  description
                    "Set to 1 to follow shortest-path";
                }

                leaf exclude-srlg {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "SRLG value to be excluded, value 0 means no
                   exclusion";
                }
              }  // list group-lsp-record
            }  // container group-lsp-records

            leaf strict {
              type empty;
              description "Disable Fallback";
            }

            leaf group-id {
              type uint32 {
                range "1..65535";
              }
              description "Group ID";
            }

            leaf dp-type {
              type Pce-disjoint-path;
              description
                "Disjointness type";
            }

            leaf sub-id {
              type uint32 {
                range "0..65535";
              }
              description
                "Sub group ID, 0 to unset";
            }
          }  // list group
        }  // container groups

        leaf maximum-attempts {
          type uint32 {
            range "1..100000";
          }
          description
            "Maximum number of attempts during disjoint path
           computation (default: 1000)";
        }
      }  // container disjoint-path

      container peer-filter {
        description "Peer filter";
        leaf ipv4-acl {
          type string;
          description
            "IPv4 ACL for peer filtering";
        }
      }  // container peer-filter

      leaf server-address {
        type inet:ipv4-address-no-zone;
        description
          "IPv4 address of PCE server";
      }

      leaf ipv6-server-address {
        type inet:ipv6-address-no-zone;
        description
          "IPv6 address of PCE server";
      }

      leaf password {
        type xr:Proprietary-password;
        description "MD5 password";
      }

      uses CONSTRAINTS;
    }  // container pce
  }  // module Cisco-IOS-XR-infra-xtc-cfg