Cisco-IOS-XR-um-router-isis-cfg

This module contains a collection of YANG definitions for Cisco IOS-XR router-isis package configuration. This YANG module augm...

  • Version: 2021-05-18

    Cisco-IOS-XR-um-router-isis-cfg@2021-05-18


    
      module Cisco-IOS-XR-um-router-isis-cfg {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-um-router-isis-cfg";
    
        prefix um-router-isis-cfg;
    
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import ietf-inet-types {
          prefix inet;
        }
        import Cisco-IOS-XR-um-snmp-server-cfg {
          prefix a1;
        }
        import tailf-common {
          prefix tailf;
        }
        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 router-isis package configuration.
         
         This YANG module augments the
         modules with configuration data.
         
         Copyright (c) 2019-2021 by Cisco Systems, Inc.
         All rights reserved.";
    
        revision "2021-05-18" {
          description
            "Added features, 1. flex-algo srlg exclude
           2. advertise application flex-algo link-attributes srlg
           2021-04-22
             Added te-metric flex-algo feature
           2021-03-02
             Re-ordered maximum-wait, initial-wait and secondary-wait nodes under
           level container
           2021-02-11
             Re-ordered per-link, per-prefix nodes under interface fast-reroute container
           2021-01-28
             Added cisco-support task yang nodes
           2021-01-27
             Re-ordered nodes under lsp-gen-interval, min-lsp-arrivaltime container
           2021-01-20
             Moved presence containers as leafs under snmp-server traps
           2021-01-18
             Added presence statement and re-ordered few nodes under container max-metric
           2021-01-11
             Add support to metric and preferred container under tunnel
           2021-01-07
             Updated range value in leaf multiplier under fallback container
           2021-01-06
             Added presence statement under link-state container
           2020-12-09
             Removed cisco-support yang nodes
           2020-12-01
             Added container anomaly under metric/fallback
           2020-11-20
             Added metric type te
           2020-11-19
             Fixed a must statement under absolute, added presence statement to text
           2020-11-13
             Added container receive and attestation under list process.
           2020-11-02
             Moved levels container under lsp-password out of it and renamed as
           lsp-password-levels.
           2020-08-20
             Added level option under srv6/locator
           2020-08-13
             Remove presence container and constraints on the match container
           2020-08-10
             Updated the fallback topology
           2020-07-21
             Slight changes to prefix-priority nodes
           2020-07-17
             Added must statements and moved rib-update-delay up one node
           2020-07-15
             Added down-flag-clear node under redistribute isis
           2020-07-14
             Added mandatory node to bit-position under affinity-map";
        }
    
        revision "2020-05-19" {
          description
            "Added nodes for new ISIS features
           2020-05-07
           Added a container anycast and its child nodes
           2020-04-14
           Updated the constraints in the nodes under stagger to be less strict
           2020-03-09
           Updated lsp-password and summary-prefix trees with proper constaraint
           statements";
        }
    
        revision "2019-06-10" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2019-03-30" {
          description "Initial draft";
        }
    
        semver:module-version "3.0.0";
        semver:module-version "2.0.0";
        semver:module-version "1.0.0";
    
        typedef Isis-af-name {
          type enumeration {
            enum "ipv4" {
              value 0;
              description "IPv4";
            }
            enum "ipv6" {
              value 1;
              description "IPv6";
            }
          }
          description "Address-family names";
        }
    
        typedef Isis-saf-name {
          type enumeration {
            enum "unicast" {
              value 0;
              description "unicast";
            }
            enum "multicast" {
              value 1;
              description "multicast";
            }
          }
          description "Sub address-family names";
        }
    
        typedef Isis-saf-multicast {
          type enumeration {
            enum "multicast" {
              value 1;
              description "multicast";
            }
          }
          description
            "Sub address-family names (only multicast)";
        }
    
        augment /a1:snmp-server/a1:traps {
          container isis {
            must
              "not(all = 'enable' and
             (database-overload = 'enable' or
             manual-address-drops = 'enable' or
             corrupted-lsp-detected = 'enable' or
             attempt-to-exceed-max-sequence = 'enable' or
             id-len-mismatch = 'enable' or
             max-area-addresses-mismatch = 'enable' or
             own-lsp-purge = 'enable' or
             sequence-number-skip = 'enable' or
             authentication-type-failure = 'enable' or
             authentication-failure = 'enable' or
             version-skew = 'enable' or
             area-mismatch = 'enable' or
             rejected-adjacency = 'enable' or
             lsp-too-large-to-propagate = 'enable' or
             orig-lsp-buff-size-mismatch = 'enable' or
             protocols-supported-mismatch = 'enable' or
             adjacency-change = 'enable' or
             lsp-error-detected = 'enable'))";
            presence
              "Indicates a isis node is configured.";
            description "Enable IS-IS traps";
            leaf all {
              type enumeration {
                enum "enable" {
                  value 19;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "Enable all IS-IS traps";
            }
    
            leaf database-overload {
              type enumeration {
                enum "enable" {
                  value 1;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisDatabaseOverload";
            }
    
            leaf manual-address-drops {
              type enumeration {
                enum "enable" {
                  value 2;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisManualAddressDrops";
            }
    
            leaf corrupted-lsp-detected {
              type enumeration {
                enum "enable" {
                  value 3;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisCorruptedLSPDetected";
            }
    
            leaf attempt-to-exceed-max-sequence {
              type enumeration {
                enum "enable" {
                  value 4;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisAttemptToExceedMaxSequence";
            }
    
            leaf id-len-mismatch {
              type enumeration {
                enum "enable" {
                  value 5;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisIDLenMismatch";
            }
    
            leaf max-area-addresses-mismatch {
              type enumeration {
                enum "enable" {
                  value 6;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisMaxAreaAddressesMismatch";
            }
    
            leaf own-lsp-purge {
              type enumeration {
                enum "enable" {
                  value 7;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisOwnLSPPurge";
            }
    
            leaf sequence-number-skip {
              type enumeration {
                enum "enable" {
                  value 8;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisSequenceNumberSkip";
            }
    
            leaf authentication-type-failure {
              type enumeration {
                enum "enable" {
                  value 9;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisAuthenticationTypeFailure";
            }
    
            leaf authentication-failure {
              type enumeration {
                enum "enable" {
                  value 10;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisAuthenticationFailure";
            }
    
            leaf version-skew {
              type enumeration {
                enum "enable" {
                  value 11;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisVersionSkew";
            }
    
            leaf area-mismatch {
              type enumeration {
                enum "enable" {
                  value 12;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisAreaMismatch";
            }
    
            leaf rejected-adjacency {
              type enumeration {
                enum "enable" {
                  value 13;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisRejectedAdjacency";
            }
    
            leaf lsp-too-large-to-propagate {
              type enumeration {
                enum "enable" {
                  value 14;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisLSPTooLargeToPropagate";
            }
    
            leaf orig-lsp-buff-size-mismatch {
              type enumeration {
                enum "enable" {
                  value 15;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisOrigLSPBuffSizeMismatch";
            }
    
            leaf protocols-supported-mismatch {
              type enumeration {
                enum "enable" {
                  value 16;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description
                "isisProtocolsSupportedMismatch";
            }
    
            leaf adjacency-change {
              type enumeration {
                enum "enable" {
                  value 17;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisAdjacencyChange";
            }
    
            leaf lsp-error-detected {
              type enumeration {
                enum "enable" {
                  value 18;
                  description "Enable the trap";
                }
                enum "disable" {
                  value 0;
                  description "Disable the trap";
                }
              }
              mandatory true;
              description "isisLSPErrorDetected";
            }
          }  // container isis
        }
    
        container router {
          description "Enable a routing process";
          container isis {
            description "ISO IS-IS";
            container processes {
              description "Process ID";
              list process {
                key "process-id";
                description "Process ID";
                leaf process-id {
                  type string {
                    length "1..36";
                  }
                  description "Process ID";
                }
    
                container nsr {
                  presence
                    "Indicates a nsr node is configured.";
                  description "Enable NSR";
                }  // container nsr
    
                container ignore-lsp-errors {
                  description
                    "Ignore LSPs with bad checksums instead of purging the LSP";
                  container disable {
                    presence
                      "Indicates a disable node is configured.";
                    description
                      "Purge LSPs with failed checksums";
                  }  // container disable
                }  // container ignore-lsp-errors
    
                leaf instance-id {
                  type uint32 {
                    range "1..65535";
                  }
                  description
                    "ISIS-MI instance id";
                }
    
                leaf is-type {
                  type enumeration {
                    enum "level-1" {
                      value 1;
                      description
                        "Act as a station router only";
                    }
                    enum "level-2-only" {
                      value 2;
                      description
                        "Act as an area router only";
                    }
                    enum "level-1-2" {
                      value 3;
                      description
                        "Act as both a station router and an area router";
                    }
                  }
                  description
                    "Area type (level)";
                }
    
                container log {
                  description "Enable logging";
                  container adjacency {
                    description
                      "Enable logging of adjacency state";
                    container changes {
                      presence
                        "Indicates a changes node is configured.";
                      description
                        "Enable logging adjacency state changes";
                    }  // container changes
                  }  // container adjacency
    
                  container pdu {
                    description
                      "Enable PDU logging";
                    container drops {
                      presence
                        "Indicates a drops node is configured.";
                      description
                        "Enable logging PDU drops";
                    }  // container drops
                  }  // container pdu
                }  // container log
    
                container lsp-password {
                  must
                    "text or hmac-md5 or keychain";
                  presence
                    "Indicates a lsp-password node is configured.";
                  description
                    "Configure the area password";
                  container text {
                    must
                      "not(../hmac-md5 or ../keychain)";
                    presence
                      "Indicates a text node is configured.";
                    description
                      "Use cleartext password authentication";
                    leaf encrypted {
                      type xr:Proprietary-password;
                      mandatory true;
                      description
                        "The encrypted LSP/SNP password";
                    }
                  }  // container text
    
                  container hmac-md5 {
                    must
                      "not(../text or ../keychain)";
                    presence
                      "Indicates a hmac-md5 node is configured.";
                    description
                      "Use HMAC-MD5 authentication";
                    leaf encrypted {
                      type xr:Proprietary-password;
                      mandatory true;
                      description
                        "The encrypted LSP/SNP password";
                    }
                  }  // container hmac-md5
    
                  container keychain {
                    must
                      "not(../hmac-md5 or ../text)";
                    presence
                      "Indicates a keychain node is configured.";
                    description
                      "Specifies a Key Chain name will follow";
                    leaf keychain-name {
                      type string {
                        length "1..1024";
                      }
                      mandatory true;
                      description
                        "Specifies a Key Chain name will follow";
                    }
                  }  // container keychain
    
                  container send-only {
                    must
                      "../text or ../hmac-md5 or ../keychain";
                    presence
                      "Indicates a send-only node is configured.";
                    description
                      "Authenticate outgoing LSPs/SNPs only";
                  }  // container send-only
    
                  container snp {
                    description
                      "Specify SNP packets authentication mode";
                    container send-only {
                      must "../../text";
                      presence
                        "Indicates a send-only node is configured.";
                      description
                        "Authenticate outgoing SNPs, no check on incoming SNPs";
                    }  // container send-only
                  }  // container snp
    
                  container enable-poi {
                    must
                      "../hmac-md5 or ../keychain";
                    presence
                      "Indicates a enable-poi node is configured.";
                    description
                      "Enable purge originator identification";
                  }  // container enable-poi
                }  // container lsp-password
    
                container lsp-password-levels {
                  description
                    "Set lsp-password for one level only";
                  list level {
                    must
                      "text or hmac-md5 or keychain";
                    key "level-id";
                    description
                      "Set lsp-password for one level only";
                    leaf level-id {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Set lsp-password for one level only";
                    }
    
                    container text {
                      must
                        "not(../hmac-md5 or ../keychain)";
                      presence
                        "Indicates a hmac-md5 node is configured.";
                      description
                        "Use cleartext password authentication";
                      leaf encrypted {
                        type xr:Proprietary-password;
                        mandatory true;
                        description
                          "The encrypted LSP/SNP password";
                      }
                    }  // container text
    
                    container hmac-md5 {
                      must
                        "not(../text or ../keychain)";
                      presence
                        "Indicates a hmac-md5 node is configured.";
                      description
                        "Use HMAC-MD5 authentication";
                      leaf encrypted {
                        type xr:Proprietary-password;
                        mandatory true;
                        description
                          "The encrypted LSP/SNP password";
                      }
                    }  // container hmac-md5
    
                    container keychain {
                      must
                        "not(../text or ../hmac-md5)";
                      presence
                        "Indicates a keychain node is configured.";
                      description
                        "Specifies a Key Chain name will follow";
                      leaf keychain-name {
                        type string {
                          length "1..1024";
                        }
                        mandatory true;
                        description
                          "Specifies a Key Chain name will follow";
                      }
                    }  // container keychain
    
                    container send-only {
                      must
                        "../text or ../hmac-md5 or ../keychain";
                      presence
                        "Indicates a send-only node is configured.";
                      description
                        "Authenticate outgoing LSPs/SNPs only";
                    }  // container send-only
    
                    container snp {
                      description
                        "Specify SNP packets authentication mode";
                      container send-only {
                        must "../../text";
                        presence
                          "Indicates a send-only node is configured.";
                        description
                          "Authenticate outgoing SNPs, no check on incoming SNPs";
                      }  // container send-only
                    }  // container snp
    
                    container enable-poi {
                      must
                        "../hmac-md5 or ../keychain";
                      presence
                        "Indicates a enable-poi node is configured.";
                      description
                        "Enable purge originator identification";
                    }  // container enable-poi
                  }  // list level
    
                  container accept {
                    description
                      "Use password for incoming authentication only";
                    leaf encrypted {
                      type xr:Proprietary-password;
                      description
                        "The encrypted LSP/SNP password";
                    }
    
                    container levels {
                      description
                        "Set lsp-password for one level only";
                      list level {
                        key "level-id";
                        description
                          "Set lsp-password for one level only";
                        leaf level-id {
                          type uint32 {
                            range "1..2";
                          }
                          description
                            "Set lsp-password for one level only";
                        }
    
                        leaf encrypted {
                          type xr:Proprietary-password;
                          mandatory true;
                          description
                            "The encrypted LSP/SNP password";
                        }
                      }  // list level
                    }  // container levels
                  }  // container accept
                }  // container lsp-password-levels
    
                leaf vrf-context {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "VRF context for this ISIS process";
                }
    
                container hostname {
                  description
                    "Dynamic hostname resolution for show/debug output";
                  container dynamic {
                    description
                      "Dynamic hostname resolution";
                    container disable {
                      presence
                        "Indicates a disable node is configured.";
                      description
                        "Disable dynamic hostname resolution";
                    }  // container disable
                  }  // container dynamic
                }  // container hostname
    
                container lsp-check-interval {
                  description
                    "Set LSP checksum check interval";
                  leaf lsp-check-interval-time {
                    type uint32 {
                      range "10..65535";
                    }
                    description
                      "Set LSP checksum check interval";
                  }
    
                  container levels {
                    description
                      "Set LSP check interval for one level only";
                    list level {
                      key "level-id";
                      description
                        "Set LSP check interval for one level only";
                      leaf level-id {
                        type uint32 {
                          range "1..2";
                        }
                        description
                          "Set LSP check interval for one level only";
                      }
    
                      leaf lsp-check-interval-time {
                        type uint32 {
                          range "10..65535";
                        }
                        mandatory true;
                        description
                          "Set LSP checksum check interval";
                      }
                    }  // list level
                  }  // container levels
                }  // container lsp-check-interval
    
                container lsp-gen-interval {
                  must
                    "maximum-wait or initial-wait or secondary-wait";
                  presence
                    "Indicates a lsp-gen-interval node is configured.";
                  description
                    "System and Pseudonode LSP generation scheduling parameters";
                  leaf maximum-wait {
                    type uint32 {
                      range "0..120000";
                    }
                    description
                      "Maximum delay before generating an LSP";
                  }
    
                  leaf initial-wait {
                    type uint32 {
                      range "0..120000";
                    }
                    description
                      "Initial delay before generating an LSP";
                  }
    
                  leaf secondary-wait {
                    type uint32 {
                      range "0..120000";
                    }
                    description
                      "Secondary delay before generating an LSP";
                  }
                }  // container lsp-gen-interval
    
                container lsp-gen-interval-levels {
                  description
                    "Set LSP generation interval for one level only";
                  list level {
                    must
                      "maximum-wait or initial-wait or secondary-wait";
                    key "level-id";
                    description
                      "Set LSP generation interval for one level only";
                    leaf level-id {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Set LSP generation interval for one level only";
                    }
    
                    leaf maximum-wait {
                      type uint32 {
                        range "0..120000";
                      }
                      description
                        "Maximum delay before generating an LSP";
                    }
    
                    leaf initial-wait {
                      type uint32 {
                        range "0..120000";
                      }
                      description
                        "Initial delay before generating an LSP";
                    }
    
                    leaf secondary-wait {
                      type uint32 {
                        range "0..120000";
                      }
                      description
                        "Secondary delay before generating an LSP";
                    }
                  }  // list level
                }  // container lsp-gen-interval-levels
    
                container max-lsp-lifetime {
                  description
                    "Set maximum LSP lifetime";
                  leaf max-lsp-lifetime {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Set maximum LSP lifetime";
                  }
    
                  container levels {
                    description
                      "Set LSP regeneration interval for one level only";
                    list level {
                      key "level-id";
                      description
                        "Set LSP regeneration interval for one level only";
                      leaf level-id {
                        type uint32 {
                          range "1..2";
                        }
                        description
                          "Set LSP regeneration interval for one level only";
                      }
    
                      leaf max-lsp-lifetime {
                        type uint32 {
                          range "1..65535";
                        }
                        mandatory true;
                        description
                          "Set maximum LSP lifetime";
                      }
                    }  // list level
                  }  // container levels
                }  // container max-lsp-lifetime
    
                container min-lsp-arrivaltime {
                  must
                    "maximum-wait or initial-wait or secondary-wait";
                  presence
                    "Indicates a min-lsp-arrivaltime node is configured.";
                  description
                    "Set minimum arrival time of incoming LSPs";
                  leaf maximum-wait {
                    type uint32 {
                      range "0..120000";
                    }
                    description
                      "Maximum delay expected to take since last LSP";
                  }
    
                  leaf initial-wait {
                    type uint32 {
                      range "0..120000";
                    }
                    description
                      "Initial delay expected to take since last LSP";
                  }
    
                  leaf secondary-wait {
                    type uint32 {
                      range "0..120000";
                    }
                    description
                      "Secondary delay expected to take since last LSP";
                  }
                }  // container min-lsp-arrivaltime
    
                container min-lsp-arrivaltime-levels {
                  description
                    "Set LSP arrival time for one level only";
                  list level {
                    must
                      "maximum-wait or initial-wait or secondary-wait";
                    key "level-id";
                    description
                      "Set LSP arrival time for one level only";
                    leaf level-id {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Set LSP arrival time for one level only";
                    }
    
                    leaf maximum-wait {
                      type uint32 {
                        range "0..120000";
                      }
                      description
                        "Maximum delay expected to take since last LSP";
                    }
    
                    leaf initial-wait {
                      type uint32 {
                        range "0..120000";
                      }
                      description
                        "Initial delay expected to take since last LSP";
                    }
    
                    leaf secondary-wait {
                      type uint32 {
                        range "0..120000";
                      }
                      description
                        "Secondary delay expected to take since last LSP";
                    }
                  }  // list level
                }  // container min-lsp-arrivaltime-levels
    
                container lsp-mtu {
                  description
                    "Set maximum LSP size";
                  leaf lsp-mtu-size {
                    type uint32 {
                      range "128..8979";
                    }
                    description
                      "Set maximum LSP size";
                  }
    
                  container levels {
                    description
                      "Set LSP size for one level only";
                    list level {
                      key "level-id";
                      description
                        "Set LSP size for one level only";
                      leaf level-id {
                        type uint32 {
                          range "1..2";
                        }
                        description
                          "Set LSP size for one level only";
                      }
    
                      leaf lsp-mtu-size {
                        type uint32 {
                          range "128..8979";
                        }
                        mandatory true;
                        description
                          "Set maximum LSP size";
                      }
                    }  // list level
                  }  // container levels
                }  // container lsp-mtu
    
                container lsp-refresh-interval {
                  description
                    "Set LSP refresh interval";
                  leaf lsp-refresh-interval-time {
                    type uint32 {
                      range "1..65535";
                    }
                    description
                      "Set LSP refresh interval";
                  }
    
                  container levels {
                    description
                      "Set LSP refresh interval for one level only";
                    list level {
                      key "level-id";
                      description
                        "Set LSP refresh interval for one level only";
                      leaf level-id {
                        type uint32 {
                          range "1..2";
                        }
                        description
                          "Set LSP refresh interval for one level only";
                      }
    
                      leaf lsp-refresh-interval-time {
                        type uint32 {
                          range "1..65535";
                        }
                        mandatory true;
                        description
                          "Set LSP refresh interval";
                      }
                    }  // list level
                  }  // container levels
                }  // container lsp-refresh-interval
    
                container max-metric {
                  presence
                    "Indicates a no-options node is configured.";
                  description
                    "Signal other routers to use us as transit option of last resort";
                  container on-startup {
                    description
                      "Set maximum metric temporarily after reboot";
                    container advertise-maximum-metric {
                      must
                        "not(../wait-for-bgp)";
                      presence
                        "Indicates a advertise-maximum-metric node is configured.";
                      description
                        "Time in seconds to advertise maximum metric after reboot";
                      leaf time-to-advertise {
                        type uint32 {
                          range "5..86400";
                        }
                        mandatory true;
                        description
                          "Time in seconds to advertise maximum metric after reboot";
                      }
                    }  // container advertise-maximum-metric
    
                    container wait-for-bgp {
                      must
                        "not(../advertise-maximum-metric)";
                      presence
                        "Indicates a wait-for-bgp node is configured.";
                      description
                        "Set maximum metric on startup until BGP signalsconvergence, or timeout";
                    }  // container wait-for-bgp
    
                    container external {
                      presence
                        "Indicates a external node is configured.";
                      description
                        "Override metric of prefixes learned from another protocol with maximum metric";
                    }  // container external
    
                    container interlevel {
                      presence
                        "Indicates a interlevel node is configured.";
                      description
                        "Override metric of prefixes learned from another ISIS level with maximum metric";
                    }  // container interlevel
    
                    container default-route {
                      presence
                        "Indicates a default-route node is configured.";
                      description
                        "Override default route metric with maximum metric";
                    }  // container default-route
    
                    container srv6-locator {
                      presence
                        "Indicates a srv6-locator node is configured.";
                      description
                        "Override segment routing ipv6 metric with maximum metric";
                    }  // container srv6-locator
                  }  // container on-startup
                }  // container max-metric
    
                container max-metric-levels {
                  description
                    "Set maximum metric for one level only";
                  list level {
                    key "level-id";
                    description
                      "Set maximum metric for one level only";
                    leaf level-id {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Set maximum metric for one level only";
                    }
    
                    container advertise-maximum-metric {
                      must
                        "not(../wait-for-bgp)";
                      presence
                        "Indicates a advertise-maximum-metric node is configured.";
                      description
                        "Time in seconds to advertise maximum metric after reboot";
                      leaf time-to-advertise {
                        type uint32 {
                          range "5..86400";
                        }
                        mandatory true;
                        description
                          "Time in seconds to advertise maximum metric after reboot";
                      }
                    }  // container advertise-maximum-metric
    
                    container wait-for-bgp {
                      must
                        "not(../advertise-maximum-metric)";
                      presence
                        "Indicates a wait-for-bgp node is configured.";
                      description
                        "Set maximum metric on startup until BGP signalsconvergence, or timeout";
                    }  // container wait-for-bgp
    
                    container external {
                      presence
                        "Indicates a external node is configured.";
                      description
                        "Override metric of prefixes learned from another protocol with maximum metric";
                    }  // container external
    
                    container interlevel {
                      presence
                        "Indicates a interlevel node is configured.";
                      description
                        "Override metric of prefixes learned from another ISIS level with maximum metric";
                    }  // container interlevel
    
                    container default-route {
                      presence
                        "Indicates a default-route node is configured.";
                      description
                        "Override default route metric with maximum metric";
                    }  // container default-route
    
                    container srv6-locator {
                      presence
                        "Indicates a srv6-locator node is configured.";
                      description
                        "Override segment routing ipv6 metric with maximum metric";
                    }  // container srv6-locator
                  }  // list level
                }  // container max-metric-levels
    
                container set-overload-bit {
                  presence
                    "Indicates a set-overloaded-bit node is configured.";
                  description
                    "Signal other routers not to use us in SPF";
                  container on-startup {
                    description
                      "Set overload-bit temporarily after reboot";
                    container advertise-as-overloaded {
                      must
                        "not(../wait-for-bgp)";
                      presence
                        "Indicates a advertise-as-overloaded node is configured.";
                      description
                        "Time in seconds to advertise ourself as overloaded after reboot";
                      leaf time-to-advertise {
                        type uint32 {
                          range "5..86400";
                        }
                        mandatory true;
                        description
                          "Time in seconds to advertise ourself as overloaded after reboot";
                      }
                    }  // container advertise-as-overloaded
    
                    container wait-for-bgp {
                      must
                        "not(../advertise-as-overloaded)";
                      presence
                        "Indicates a wait-for-bgp node is configured.";
                      description
                        "Set overload bit on startup until BGP signals convergence, or timeout";
                    }  // container wait-for-bgp
                  }  // container on-startup
    
                  container advertise {
                    description
                      "If overload-bit set advertise the following types of IP prefixes";
                    container external {
                      presence
                        "Indicates a external node is configured.";
                      description
                        "If overload-bit set advertise IP prefixes learned from other protocols";
                    }  // container external
    
                    container interlevel {
                      presence
                        "Indicates a interlevel node is configured.";
                      description
                        "If overload-bit set advertise IP prefixes learned from another ISIS level";
                    }  // container interlevel
                  }  // container advertise
                }  // container set-overload-bit
    
                container set-overload-bit-levels {
                  description
                    "Set overload-bit for one level only";
                  list level {
                    key "level-id";
                    description
                      "Set overload-bit for one level only";
                    leaf level-id {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Set overload-bit for one level only";
                    }
    
                    container on-startup {
                      description
                        "Set overload-bit temporarily after reboot";
                      container advertise-as-overloaded {
                        must
                          "not(../wait-for-bgp)";
                        presence
                          "Indicates a advertise-as-overloaded node is configured.";
                        description
                          "Time in seconds to advertise ourself as overloaded after reboot";
                        leaf time-to-advertise {
                          type uint32 {
                            range "5..86400";
                          }
                          mandatory true;
                          description
                            "Time in seconds to advertise ourself as overloaded after reboot";
                        }
                      }  // container advertise-as-overloaded
    
                      container wait-for-bgp {
                        must
                          "not(../advertise-as-overloaded)";
                        presence
                          "Indicates a wait-for-bgp node is configured.";
                        description
                          "Set overload bit on startup until BGP signals convergence, or timeout";
                      }  // container wait-for-bgp
                    }  // container on-startup
    
                    container advertise {
                      description
                        "If overload-bit set advertise the following types of IP prefixes";
                      container external {
                        presence
                          "Indicates a external node is configured.";
                        description
                          "If overload-bit set advertise IP prefixes learned from other protocols";
                      }  // container external
    
                      container interlevel {
                        presence
                          "Indicates a interlevel node is configured.";
                        description
                          "If overload-bit set advertise IP prefixes learned from another ISIS level";
                      }  // container interlevel
                    }  // container advertise
                  }  // list level
                }  // container set-overload-bit-levels
    
                container nets {
                  description
                    "A Network Entity Title (NET) for this process";
                  list net {
                    key "net-id";
                    description
                      "A Network Entity Title (NET) for this process";
                    leaf net-id {
                      type string {
                        length "1..1024";
                      }
                      description
                        "A Network Entity Title (NET) for this process";
                    }
                  }  // list net
                }  // container nets
    
                container link-groups {
                  description "Link Group";
                  list link-group {
                    key "link-group-name";
                    description "Link Group";
                    leaf link-group-name {
                      type string {
                        length "1..1024";
                      }
                      description "Link Group";
                    }
    
                    leaf minimum-members {
                      type uint32 {
                        range "2..64";
                      }
                      description
                        "Minimum number of members in the link group";
                    }
    
                    leaf revert-members {
                      type uint32 {
                        range "2..64";
                      }
                      description
                        "Number of members after which to revert in the link group";
                    }
    
                    container metric-offset {
                      description
                        "Configure the metric offset for link group";
                      container maximum {
                        presence
                          "Indicates a maximum node is configured.";
                        description
                          "Maximum wide metric offset. All routers will exclude this link from their SPF";
                      }  // container maximum
    
                      leaf default-metric-offset {
                        type uint32 {
                          range "1..16777214";
                        }
                        description
                          "Default metric offset: <1-63> for narrow, <1-16777214> for wide";
                      }
                    }  // container metric-offset
                  }  // list link-group
                }  // container link-groups
    
                container nsf {
                  description
                    "Allow non-stop forwarding (NSF) on next restart";
                  leaf lifetime {
                    type uint32 {
                      range "5..300";
                    }
                    description
                      "Maximum route lifetime following restart (seconds)";
                  }
    
                  leaf interface-timer {
                    type uint32 {
                      range "1..20";
                    }
                    description
                      "Timer used to wait for a restart ACK (seconds)";
                  }
    
                  leaf interface-expires {
                    type uint32 {
                      range "1..10";
                    }
                    description
                      "# of times T1 can expire waiting for the restart ACK";
                  }
    
                  container cisco {
                    must "not(../ietf)";
                    presence
                      "Indicates a cisco node is configured.";
                    description
                      "Cisco Proprietary NSF restart";
                  }  // container cisco
    
                  container ietf {
                    must "not(../cisco)";
                    presence
                      "Indicates a ietf node is configured.";
                    description
                      "IETF NSF restar";
                  }  // container ietf
                }  // container nsf
    
                container trace {
                  description
                    "Set trace buffer parameters";
                  leaf mode {
                    type enumeration {
                      enum "off" {
                        value 0;
                        description "No tracing";
                      }
                      enum "basic" {
                        value 1;
                        description
                          "Basic tracing (less overhead)";
                      }
                      enum "enhanced" {
                        value 2;
                        description
                          "Enhanced tracing (more overhead)";
                      }
                    }
                    description
                      "Set tracing type";
                  }
    
                  leaf detailed {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for detailed traces";
                  }
    
                  leaf standard {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for standard traces";
                  }
    
                  leaf severe {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for severe traces";
                  }
    
                  leaf hello {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for hello traces";
                  }
    
                  leaf startup {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for startup traces";
                  }
    
                  leaf config {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for config traces";
                  }
    
                  leaf lspgen {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for lspgen traces";
                  }
    
                  leaf adj {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for adj traces";
                  }
    
                  leaf spf {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for spf traces";
                  }
    
                  leaf sr {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for sr traces";
                  }
    
                  leaf rib {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for rib traces";
                  }
    
                  leaf te {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for te traces";
                  }
    
                  leaf update {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for update traces";
                  }
    
                  leaf pkt {
                    type uint32 {
                      range "1..1000000";
                    }
                    description
                      "Buffer size for pkt traces";
                  }
                }  // container trace
    
                leaf triggers {
                  type string {
                    length "1..1024";
                  }
                  description
                    "Set logging triggers for performance testing";
                }
    
                container address-families {
                  description
                    "Enter the IS-IS address-family configuration submode";
                  list address-family {
                    key "af-name saf-name";
                    description
                      "IS-IS address family";
                    leaf af-name {
                      type Isis-af-name;
                      description
                        "Address family name";
                    }
    
                    leaf saf-name {
                      type Isis-saf-name;
                      description
                        "Sub address family name";
                    }
    
                    container default-information {
                      description
                        "Control distribution of default information";
                      container originate {
                        presence
                          "Indicates a originate node is configured.";
                        description
                          "Distribute a default route";
                        container external {
                          presence
                            "Indicates a external node is configured.";
                          description
                            "Originate default prefix as an external route";
                        }  // container external
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
                      }  // container originate
                    }  // container default-information
    
                    container segment-routing {
                      description
                        "Enable Segment Routing";
                      container mpls {
                        description
                          "Enable Segment Routing using MPLS encapsulation";
                        leaf sr-prefer {
                          when
                            "../../../saf-name = 'unicast'";
                          type boolean;
                          description
                            "Prefer segment routing labels over LDP labels";
                        }
    
                        container unlabeled {
                          when
                            "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'";
                          description
                            "Options for prefixes without a segment-routing label";
                          container protection {
                            description
                              "TI-LFA and microloop protection";
                            leaf prefix-list {
                              type xr:Cisco-ios-xr-string {
                                length "1..1024";
                              }
                              must
                                "not(../route-policy or ../disable)";
                              description
                                "Enable TI-LFA and microloop protection based on a prefix list";
                            }
    
                            leaf route-policy {
                              type xr:Route-policy-name;
                              must
                                "not(../prefix-list or ../disable)";
                              description
                                "Enable TI-LFA and microloop protection based on a route policy";
                            }
    
                            container disable {
                              must
                                "not(../prefix-list or ../route-policy)";
                              presence
                                "Indicates a disable node is configured.";
                              description
                                "Disable TI-LFA and microloop protection";
                            }  // container disable
                          }  // container protection
                        }  // container unlabeled
    
                        container connected-prefix-sid-map {
                          presence
                            "Indicates a connected-prefix-sid-map node is configured.";
                          description
                            "Enter connected prefix sid map submode";
                          container prefixes {
                            when
                              "../../../../saf-name = 'unicast'";
                            description
                              "Specify prefix associated with this Prefix Segement ID";
                            list prefix {
                              must
                                "index or absolute";
                              key "address-prefix";
                              description
                                "Specify prefix associated with this Prefix Segement ID";
                              leaf address-prefix {
                                type inet:ip-prefix;
                                description
                                  "Specify prefix associated with this Prefix Segement ID";
                              }
    
                              container index {
                                must
                                  "not(../absolute)";
                                presence
                                  "Indicates a index node is configured.";
                                description
                                  "Specify the index of Prefix Segement ID";
                                leaf index-id {
                                  type uint32 {
                                    range
                                      "0..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the index of Prefix Segement ID";
                                }
                              }  // container index
    
                              container absolute {
                                must
                                  "not(../index)";
                                presence
                                  "Indicates a absolute node is configured.";
                                description
                                  "Specify the absolute value of Prefix Segement ID";
                                leaf absolute-value {
                                  type uint32 {
                                    range
                                      "16000..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the absolute value of Prefix Segement ID";
                                }
                              }  // container absolute
    
                              container explicit-null {
                                presence
                                  "Indicates a explicit-null node is configured.";
                                description
                                  "Upstream neighbor must replace prefix-sid with explicit null label";
                              }  // container explicit-null
                            }  // list prefix
                          }  // container prefixes
    
                          container flex-algo {
                            when
                              "../../../../saf-name = 'unicast'";
                            description
                              "Specify the custom flex-algo algorithm to use";
                            list prefix {
                              must
                                "index or absolute";
                              key "address-prefix flex-algo";
                              description
                                "Specify prefix associated with this Prefix Segement ID";
                              leaf address-prefix {
                                type inet:ip-prefix;
                                description
                                  "Specify prefix associated with this Prefix Segement ID";
                              }
    
                              leaf flex-algo {
                                type uint32 {
                                  range
                                    "128..255";
                                }
                                description
                                  "Specify the custom flex-algo algorithm to use";
                              }
    
                              container index {
                                must
                                  "not(../absolute)";
                                presence
                                  "Indicates a index node is configured.";
                                description
                                  "Specify the index of Prefix Segement ID";
                                leaf index-id {
                                  type uint32 {
                                    range
                                      "0..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the index of Prefix Segement ID";
                                }
                              }  // container index
    
                              container absolute {
                                must
                                  "not(../index)";
                                presence
                                  "Indicates a absolute node is configured.";
                                description
                                  "Specify the absolute value of Prefix Segement ID";
                                leaf absolute-value {
                                  type uint32 {
                                    range
                                      "16000..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the absolute value of Prefix Segement ID";
                                }
                              }  // container absolute
    
                              container explicit-null {
                                presence
                                  "Indicates a explicit-null node is configured.";
                                description
                                  "Upstream neighbor must replace prefix-sid with explicit null label";
                              }  // container explicit-null
                            }  // list prefix
                          }  // container flex-algo
    
                          container strict-spf {
                            when
                              "../../../../saf-name = 'unicast'";
                            description
                              "Use strict-spf";
                            list prefix {
                              must
                                "index or absolute";
                              key "address-prefix";
                              description
                                "Specify prefix associated with this Prefix Segement ID";
                              leaf address-prefix {
                                type inet:ip-prefix;
                                description
                                  "Specify prefix associated with this Prefix Segement ID";
                              }
    
                              container index {
                                must
                                  "not(../absolute)";
                                presence
                                  "Indicates a index node is configured.";
                                description
                                  "Specify the index of Prefix Segement ID";
                                leaf index-id {
                                  type uint32 {
                                    range
                                      "0..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the index of Prefix Segement ID";
                                }
                              }  // container index
    
                              container absolute {
                                must
                                  "not(../index)";
                                presence
                                  "Indicates a absolute node is configured.";
                                description
                                  "Specify the absolute value of Prefix Segement ID";
                                leaf absolute-value {
                                  type uint32 {
                                    range
                                      "16000..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the absolute value of Prefix Segement ID";
                                }
                              }  // container absolute
    
                              container explicit-null {
                                presence
                                  "Indicates a explicit-null node is configured.";
                                description
                                  "Upstream neighbor must replace prefix-sid with explicit null label";
                              }  // container explicit-null
                            }  // list prefix
                          }  // container strict-spf
                        }  // container connected-prefix-sid-map
                      }  // container mpls
    
                      container prefix-sid-map {
                        when
                          "../../saf-name = 'unicast'";
                        description
                          "Enable prefix-sid-map";
                        container receive {
                          presence
                            "Indicates a receive node is configured.";
                          description
                            "Use remote mapping server advertisements";
                          container disable {
                            presence
                              "Indicates a disable node is configured.";
                            description
                              "Disable the usage of remote mapping server advertisements";
                          }  // container disable
                        }  // container receive
    
                        container advertise-local {
                          presence
                            "Indicates a advertise-local node is configured.";
                          description
                            "Advertise active local prefix-SID mappings";
                          container domain-wide {
                            presence
                              "Indicates a domain-wide node is configured.";
                            description
                              "Domain wide prefix-SID mappings";
                          }  // container domain-wide
                        }  // container advertise-local
                      }  // container prefix-sid-map
    
                      container bundle-member-adj-sid {
                        when
                          "../../saf-name = 'unicast'";
                        presence
                          "Indicates a bundle-member-adj-sid node is configured.";
                        description
                          "Enable per bundle member adjacency SID";
                      }  // container bundle-member-adj-sid
    
                      leaf protected-adjacency-sid-delay {
                        when
                          "../../saf-name = 'unicast'";
                        type uint32 {
                          range "30..3600";
                        }
                        description
                          "Protected Adjacency SID deletion delay (seconds)";
                      }
    
                      container srv6 {
                        when
                          "../../af-name = 'ipv6' and ../../saf-name = 'unicast'";
                        presence
                          "Indicates a srv6 node is configured.";
                        description
                          "Enable SRv6";
                        container locators {
                          description
                            "Enter SRv6 Locator submode";
                          list locator {
                            key "locator-name";
                            description
                              "Enter SRv6 Locator submode";
                            leaf locator-name {
                              type xr:Cisco-ios-xr-string {
                                length "1..59";
                              }
                              description
                                "Enter SRv6 Locator submode";
                            }
    
                            leaf level {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Advertise the locator only in the specified level";
                            }
                          }  // list locator
                        }  // container locators
                      }  // container srv6
                    }  // container segment-routing
    
                    container distance {
                      description
                        "Configure IS-IS administrative distances";
                      leaf global-administrative-distance {
                        type uint32 {
                          range "1..255";
                        }
                        description
                          "Configure IS-IS administrative distances";
                      }
    
                      container route-sources {
                        description
                          "Route source for this distance";
                        list route-source {
                          key "address-prefix";
                          description
                            "Route source for this distance";
                          leaf address-prefix {
                            type inet:ip-prefix;
                            description
                              "Route source for this distance";
                          }
    
                          leaf administrative-distance {
                            type uint32 {
                              range "1..255";
                            }
                            description
                              "Configure IS-IS administrative distances";
                          }
    
                          leaf prefix-access-list {
                            type string {
                              length "1..1024";
                            }
                            description
                              "Prefix-list or access-list to filter routes for this distance";
                          }
                        }  // list route-source
                      }  // container route-sources
                    }  // container distance
    
                    container distribute-list {
                      description
                        "Filter routes sent to the RIB";
                      leaf prefix-list {
                        type xr:Cisco-ios-xr-string {
                          length "1..1024";
                        }
                        description
                          "Filter routes based on a prefix list";
                      }
    
                      leaf route-policy {
                        type xr:Route-policy-name;
                        description
                          "Filter routes based on a route policy";
                      }
                    }  // container distribute-list
    
                    container redistribute {
                      description
                        "Redistribute information from another routing protocol";
                      container connected {
                        presence
                          "Indicates a connected node is configured.";
                        description
                          "Connected routes";
                        container level-1-2 {
                          must
                            "not(../level-1) and not(../level-2)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container connected
    
                      list ospf {
                        when
                          "../../af-name = 'ipv4'";
                        key "process-id";
                        description
                          "Open Shortest Path First (OSPF)";
                        leaf process-id {
                          type string {
                            length "1..1024";
                          }
                          description
                            "Open Shortest Path First (OSPF)";
                        }
    
                        container match {
                          description
                            "Redistribution of OSPF routes";
                          container internal {
                            must
                              "not(../external or ../nssa-external)";
                            presence
                              "Indicates a internal node is configured.";
                            description
                              "Redistribute OSPF internal routes";
                          }  // container internal
    
                          container external {
                            must
                              "not(../internal or ../nssa-external)";
                            presence
                              "Indicates a external node is configured.";
                            description
                              "Redistribute OSPF external routes";
                          }  // container external
    
                          container nssa-external {
                            must
                              "not(../internal or ../external)";
                            presence
                              "Indicates a nssa-external node is configured.";
                            description
                              "Redistribute OSPF NSSA external routes";
                          }  // container nssa-external
                        }  // container match
    
                        container level-1-2 {
                          must
                            "not(../level-1) and not(../level-2)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // list ospf
    
                      list ospfv3 {
                        when
                          "../../af-name = 'ipv6'";
                        key "process-id";
                        description
                          "Open Shortest Path First (OSPFv3)";
                        leaf process-id {
                          type string {
                            length "1..1024";
                          }
                          description
                            "Open Shortest Path First (OSPFv3)";
                        }
    
                        container match {
                          description
                            "Redistribution of OSPF routes";
                          container internal {
                            must
                              "not(../external or ../nssa-external)";
                            presence
                              "Indicates a internal node is configured.";
                            description
                              "Redistribute OSPF internal routes";
                          }  // container internal
    
                          container external {
                            must
                              "not(../internal or ../nssa-external)";
                            presence
                              "Indicates a external node is configured.";
                            description
                              "Redistribute OSPF external routes";
                          }  // container external
    
                          container nssa-external {
                            must
                              "not(../internal or ../external)";
                            presence
                              "Indicates a nssa-external node is configured.";
                            description
                              "Redistribute OSPF NSSA external routes";
                          }  // container nssa-external
                        }  // container match
    
                        container level-1-2 {
                          must
                            "not(../level-1) and not(../level-2)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // list ospfv3
    
                      container static {
                        presence
                          "Indicates a static node is configured.";
                        description
                          "Static routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container static
    
                      container subscriber {
                        presence
                          "Indicates a subscriber node is configured.";
                        description
                          "Subscriber routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container subscriber
    
                      container rip {
                        presence
                          "Indicates a rip node is configured.";
                        description "RIP routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container rip
    
                      container mobile {
                        presence
                          "Indicates a mobile node is configured.";
                        description
                          "Mobile routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container mobile
    
                      container applications {
                        description
                          "Application routes";
                        list application {
                          key "application-name";
                          description
                            "Application routes";
                          leaf application-name {
                            type string {
                              length "1..1024";
                            }
                            description
                              "Application routes";
                          }
    
                          container level-1-2 {
                            must
                              "not(../level-2) and not(../level-1)";
                            presence
                              "Indicates a level-1-2 node is configured.";
                            description
                              "Redistribute routes into both levels";
                          }  // container level-1-2
    
                          container level-2 {
                            must
                              "not(../level-1-2) and not(../level-1)";
                            presence
                              "Indicates a level-2 node is configured.";
                            description
                              "Redistribute routes into level 2 only (the default)";
                          }  // container level-2
    
                          container level-1 {
                            must
                              "not(../level-1-2) and not(../level-2)";
                            presence
                              "Indicates a level-1 node is configured.";
                            description
                              "Redistribute routes into level 1 only";
                          }  // container level-1
    
                          leaf metric {
                            type uint32 {
                              range
                                "0..16777215";
                            }
                            description
                              "Metric for redistributed routes";
                          }
    
                          leaf route-policy {
                            type xr:Route-policy-name;
                            description
                              "Route policy reference";
                          }
    
                          leaf metric-type {
                            type enumeration {
                              enum "internal" {
                                value 0;
                                description
                                  "Set IS-IS Internal metric type";
                              }
                              enum "external" {
                                value 1;
                                description
                                  "Set IS-IS External metric type";
                              }
                              enum
                                "rib-metric-as-internal" {
                                value 2;
                                description
                                  "Set IS-IS Internal metric type and use RIB metric";
                              }
                              enum
                                "rib-metric-as-external" {
                                value 3;
                                description
                                  "Set IS-IS External metric type and use RIB metric";
                              }
                            }
                            description
                              "IS-IS metric type for redistributed routes";
                          }
                        }  // list application
                      }  // container applications
    
                      list isis {
                        key "instance-id";
                        description "IS-IS";
                        leaf instance-id {
                          type string {
                            length "1..1024";
                          }
                          description "IS-IS";
                        }
    
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
    
                        container down-flag-clear {
                          presence
                            "Indicates a down-flag-clear node is configured.";
                          description
                            "Set the up/down bit to 0 in prefix advertisements";
                        }  // container down-flag-clear
                      }  // list isis
    
                      container bgp {
                        description
                          "Border Gateway Protocol (BGP)";
                        list as {
                          key "as-number";
                          description
                            "bgp as-number";
                          leaf as-number {
                            type xr:Bgp-as-number;
                            description
                              "bgp as-number";
                          }
    
                          container level-1-2 {
                            must
                              "not(../level-2) and not(../level-1)";
                            presence
                              "Indicates a level-1-2 node is configured.";
                            description
                              "Redistribute routes into both levels";
                          }  // container level-1-2
    
                          container level-2 {
                            must
                              "not(../level-1-2) and not(../level-1)";
                            presence
                              "Indicates a level-2 node is configured.";
                            description
                              "Redistribute routes into level 2 only (the default)";
                          }  // container level-2
    
                          container level-1 {
                            must
                              "not(../level-1-2) and not(../level-2)";
                            presence
                              "Indicates a level-1 node is configured.";
                            description
                              "Redistribute routes into level 1 only";
                          }  // container level-1
    
                          leaf metric {
                            type uint32 {
                              range
                                "0..16777215";
                            }
                            description
                              "Metric for redistributed routes";
                          }
    
                          leaf route-policy {
                            type xr:Route-policy-name;
                            description
                              "Route policy reference";
                          }
    
                          leaf metric-type {
                            type enumeration {
                              enum "internal" {
                                value 0;
                                description
                                  "Set IS-IS Internal metric type";
                              }
                              enum "external" {
                                value 1;
                                description
                                  "Set IS-IS External metric type";
                              }
                              enum
                                "rib-metric-as-internal" {
                                value 2;
                                description
                                  "Set IS-IS Internal metric type and use RIB metric";
                              }
                              enum
                                "rib-metric-as-external" {
                                value 3;
                                description
                                  "Set IS-IS External metric type and use RIB metric";
                              }
                            }
                            description
                              "IS-IS metric type for redistributed routes";
                          }
                        }  // list as
                      }  // container bgp
    
                      list eigrp {
                        key "as-number";
                        description
                          "EIGRP Protocol";
                        leaf as-number {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "EIGRP Protocol";
                        }
    
                        container match {
                          description
                            "Redistribution of EIGRP routes";
                          container internal {
                            must
                              "not(../external)";
                            presence
                              "Indicates a internal node is configured.";
                            description
                              "Redistribute EIGRP internal routes";
                          }  // container internal
    
                          container external {
                            must
                              "not(../internal)";
                            presence
                              "Indicates a external node is configured.";
                            description
                              "Redistribute EIGRP external routes";
                          }  // container external
                        }  // container match
    
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // list eigrp
                    }  // container redistribute
    
                    leaf maximum-paths {
                      type uint32 {
                        range "1..64";
                      }
                      description
                        "Maximum number of active parallel paths per route";
                    }
    
                    container router-id {
                      description
                        "Stable IP address for system";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Router ID Interface";
                      }
    
                      leaf ip-address {
                        type string;
                        description
                          "Router ID address";
                      }
                    }  // container router-id
    
                    container advertise {
                      description
                        "Control what we advertise in our LSP";
                      container passive-only {
                        presence
                          "Indicates a passive-only node is configured.";
                        description
                          "Advertise prefixes of passive interfaces only";
                      }  // container passive-only
    
                      container link {
                        description
                          "IS Neighbor attributes";
                        container attributes {
                          presence
                            "Indicates a attributes node is configured.";
                          description
                            "Advertise additional link attributes";
                        }  // container attributes
                      }  // container link
    
                      container application {
                        description
                          "Application Specific Data";
                        container lfa {
                          description
                            "LFA Application";
                          container link-attributes {
                            description
                              "Application Specific Link Attributes";
                            container srlg {
                              presence
                                "Indicates a srlg node is configured.";
                              description
                                "Shared Risk Ling Group";
                            }  // container srlg
                          }  // container link-attributes
                        }  // container lfa
    
                        container flex-algo {
                          description
                            "Flex-Algo Application";
                          container link-attributes {
                            description
                              "Application Specific Link Attributes";
                            container srlg {
                              presence
                                "Indicates a srlg node is configured.";
                              description
                                "Shared Risk Ling Group";
                            }  // container srlg
                          }  // container link-attributes
                        }  // container flex-algo
                      }  // container application
                    }  // container advertise
    
                    container ucmp {
                      description
                        "UnEqual Cost Multipath feature";
                      container variance {
                        presence
                          "Indicates a variance node is configured.";
                        description
                          "Specify Variance parameter to filter UCMP paths based on cost";
                        leaf variance-value {
                          type uint32 {
                            range "101..10000";
                          }
                          mandatory true;
                          description
                            "Specify Variance parameter to filter UCMP paths based on cost";
                        }
    
                        leaf prefix-list {
                          type xr:Cisco-ios-xr-string {
                            length "1..1024";
                          }
                          description
                            "Specify prefix-list name to filter UCMP paths based on prefixes";
                        }
                      }  // container variance
    
                      container exclude {
                        description
                          "UCMP interface exclusion information";
                        container interfaces {
                          description
                            "Exclude an interface from UCMP computation";
                          list interface {
                            key "interface-name";
                            description
                              "Exclude an interface from UCMP computation";
                            leaf interface-name {
                              type xr:Interface-name;
                              description
                                "Exclude an interface from UCMP computation";
                            }
                          }  // list interface
                        }  // container interfaces
                      }  // container exclude
    
                      leaf delay-interval {
                        type uint32 {
                          range "100..65535";
                        }
                        description
                          "UCMP delay interval";
                      }
                    }  // container ucmp
    
                    container microloop {
                      description
                        "Enable microloop protection feature";
                      container avoidance {
                        presence
                          "Indicates a avoidance node is configured.";
                        description
                          "Enable local microloop avoidance";
                        container protected {
                          must
                            "not(../segment-routing)";
                          presence
                            "Indicates a protected node is configured.";
                          description
                            "Enable microloop avoidance for only protected prefixes";
                        }  // container protected
    
                        container segment-routing {
                          must
                            "not(../protected)";
                          presence
                            "Indicates a segment-routing node is configured.";
                          description
                            "Enable segment routing microloop avoidance ";
                        }  // container segment-routing
                      }  // container avoidance
    
                      leaf avoidance-rib-update-delay {
                        type uint32 {
                          range "1000..65535";
                        }
                        description
                          "Delay in milliseconds";
                      }
                    }  // container microloop
    
                    container apply-weight {
                      description "Apply weight";
                      container ecmp-only {
                        must "not(../ucmp-only)";
                        presence
                          "Indicates a ecmp-only node is configured.";
                        description
                          "Apply weights to ecmp paths only";
                        container bandwidth {
                          presence
                            "Indicates a bandwidth node is configured.";
                          description
                            "Apply weight calculated based on interface bandwidth";
                        }  // container bandwidth
                      }  // container ecmp-only
    
                      container ucmp-only {
                        must "not(../ecmp-only)";
                        presence
                          "Indicates a ucmp-only node is configured.";
                        description
                          "Apply weights to ucmp paths only";
                      }  // container ucmp-only
                    }  // container apply-weight
    
                    container summary-prefixes {
                      presence
                        "Indicates a summary-prefix node is configured.";
                      description
                        "Configure IP address prefixes";
                      list summary-prefix {
                        key "address-prefix";
                        description
                          "Summary prefix";
                        leaf address-prefix {
                          type inet:ip-prefix;
                          description
                            "Specify prefix associated with this Prefix Segement ID";
                        }
    
                        leaf tag {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          description
                            "Set a tag";
                        }
    
                        leaf level {
                          type uint32 {
                            range "1..2";
                          }
                          description
                            "Summarize routes in one level only";
                        }
    
                        leaf algorithm {
                          when
                            "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'";
                          type uint32 {
                            range "128..255";
                          }
                          description
                            "Flexible Algorithm number";
                        }
    
                        container explicit {
                          when
                            "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'";
                          presence
                            "Indicates a explicit node is configured.";
                          description
                            "Strict flex-algo locator summarization mode";
                        }  // container explicit
                      }  // list summary-prefix
                    }  // container summary-prefixes
    
                    container metric {
                      description
                        "Configure default metric";
                      container default-metric {
                        description
                          "Default metric: <1-63> for narrow, <1-16777214> for wide";
                        leaf default-metric-value {
                          type uint32 {
                            range "1..16777214";
                          }
                          description
                            "Default metric: <1-63> for narrow, <1-16777214> for wide";
                        }
    
                        container levels {
                          description
                            "Set metric for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set metric for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set metric for one level only";
                            }
    
                            leaf default-metric-value {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              mandatory true;
                              description
                                "Default metric: <1-63> for narrow, <1-16777214> for wide";
                            }
                          }  // list level
                        }  // container levels
                      }  // container default-metric
                    }  // container metric
    
                    container metric-style {
                      description
                        "Use old-style (ISO 10589) or new-style packet formats";
                      container narrow {
                        must
                          "not(../wide or ../transition)";
                        presence
                          "Indicates a narrow node is configured.";
                        description
                          "Use old style of TLVs with narrow metric";
                      }  // container narrow
    
                      container wide {
                        must
                          "not(../narrow or ../transition)";
                        presence
                          "Indicates a wide node is configured.";
                        description
                          "Use new style of TLVs to carry wider metric";
                      }  // container wide
    
                      container transition {
                        must
                          "not(../narrow or ../wide)";
                        presence
                          "Indicates a transition node is configured.";
                        description
                          "Send and accept both styles of TLVs during transition";
                      }  // container transition
    
                      container levels {
                        description
                          "Set metric-style for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set metric-style for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set metric-style for one level only";
                          }
    
                          container narrow {
                            must
                              "not(../wide or ../transition)";
                            presence
                              "Indicates a narrow node is configured.";
                            description
                              "Use old style of TLVs with narrow metric";
                          }  // container narrow
    
                          container wide {
                            must
                              "not(../narrow or ../transition)";
                            presence
                              "Indicates a wide node is configured.";
                            description
                              "Use new style of TLVs to carry wider metric";
                          }  // container wide
    
                          container transition {
                            must
                              "not(../narrow or ../wide)";
                            presence
                              "Indicates a transition node is configured.";
                            description
                              "Send and accept both styles of TLVs during transition";
                          }  // container transition
                        }  // list level
                      }  // container levels
                    }  // container metric-style
    
                    container spf-interval {
                      description
                        "Route calculation scheduling parameters (FSPF, ISPF, PRC)";
                      container maximum-wait {
                        description
                          "Maximum delay before running a route calculation";
                        leaf maximum-wait-time {
                          type uint32 {
                            range "0..120000";
                          }
                          description
                            "Maximum delay before running a route calculation";
                        }
                      }  // container maximum-wait
    
                      container initial-wait {
                        description
                          "Initial delay before running a route calculation";
                        leaf initial-wait-time {
                          type uint32 {
                            range "0..120000";
                          }
                          description
                            "Initial delay before running a route calculation";
                        }
                      }  // container initial-wait
    
                      container secondary-wait {
                        description
                          "Secondary delay before running a route calculation";
                        leaf secondary-wait-time {
                          type uint32 {
                            range "0..120000";
                          }
                          description
                            "Secondary delay before running a route calculation";
                        }
                      }  // container secondary-wait
    
                      container levels {
                        description
                          "Set SPF interval for one level only";
                        list level {
                          must
                            "maximum-wait-time or initial-wait-time or secondary-wait-time";
                          key "level-id";
                          description
                            "Set SPF interval for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set SPF interval for one level only";
                          }
    
                          leaf maximum-wait-time {
                            type uint32 {
                              range "0..120000";
                            }
                            description
                              "Maximum delay before running a route calculation";
                          }
    
                          leaf initial-wait-time {
                            type uint32 {
                              range "0..120000";
                            }
                            description
                              "Initial delay before running a route calculation";
                          }
    
                          leaf secondary-wait-time {
                            type uint32 {
                              range "0..120000";
                            }
                            description
                              "Secondary delay before running a route calculation";
                          }
                        }  // list level
                      }  // container levels
                    }  // container spf-interval
    
                    container spf {
                      description
                        "SPF configuration";
                      container periodic {
                        description
                          "Configure the periodic SPF";
                        container interval {
                          description
                            "Set the maximum interval in between SPF runs";
                          leaf interval-time {
                            type uint32 {
                              range "1..3600";
                            }
                            description
                              "Set the maximum interval in between SPF runs";
                          }
    
                          container levels {
                            description
                              "Configure periodic SPF interval for for one level only";
                            list level {
                              key "level-id";
                              description
                                "Configure periodic SPF interval for for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Configure periodic SPF interval for for one level only";
                              }
    
                              leaf interval-time {
                                type uint32 {
                                  range
                                    "1..3600";
                                }
                                mandatory true;
                                description
                                  "Set the maximum interval in between SPF runs";
                              }
                            }  // list level
                          }  // container levels
                        }  // container interval
    
                        container disable {
                          description
                            "Disable the periodic SPF";
                          container disable-periodic-spf {
                            presence
                              "Indicates a disable node is configured.";
                            description
                              "Disable the periodic SPF";
                          }  // container disable-periodic-spf
    
                          container levels {
                            description
                              "Configure periodic SPF interval for for one level only";
                            list level {
                              must
                                "disable-periodic-spf";
                              key "level-id";
                              description
                                "Configure periodic SPF interval for for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Configure periodic SPF interval for for one level only";
                              }
    
                              container disable-periodic-spf {
                                presence
                                  "Indicates a disable node is configured.";
                                description
                                  "Disable the periodic SPF";
                              }  // container disable-periodic-spf
                            }  // list level
                          }  // container levels
                        }  // container disable
                      }  // container periodic
    
                      container prefix-priority {
                        description
                          "Configure a prefix priority list";
                        list prefix-priority {
                          must
                            "tag or access-list-name";
                          key "priority";
                          description
                            "Configure a prefix priority list";
                          leaf priority {
                            type enumeration {
                              enum "critical" {
                                value 0;
                                description
                                  "Specify critical priority prefixes";
                              }
                              enum "high" {
                                value 1;
                                description
                                  "Specify high priority prefixes";
                              }
                              enum "medium" {
                                value 2;
                                description
                                  "Specify medium priority prefixes";
                              }
                            }
                            description
                              "prefix priority";
                          }
    
                          leaf tag {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "not(../access-list-name)";
                            description
                              "Specify a tag to indicate priority";
                          }
    
                          leaf access-list-name {
                            type string {
                              length "1..1024";
                            }
                            must "not(../tag)";
                            description
                              "Access-list name";
                          }
                        }  // list prefix-priority
    
                        container levels {
                          description
                            "Configure SPF prefix priority list for one level only";
                          list level {
                            must
                              "tag or access-list-name";
                            key "level-id priority";
                            description
                              "Configure SPF prefix priority list for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Configure SPF prefix priority list for one level only";
                            }
    
                            leaf priority {
                              type enumeration {
                                enum "critical" {
                                  value 0;
                                  description
                                    "Specify critical priority prefixes";
                                }
                                enum "high" {
                                  value 1;
                                  description
                                    "Specify high priority prefixes";
                                }
                                enum "medium" {
                                  value 2;
                                  description
                                    "Specify medium priority prefixes";
                                }
                              }
                              description
                                "prefix priority";
                            }
    
                            leaf tag {
                              type uint32 {
                                range
                                  "1..4294967295";
                              }
                              must
                                "not(../access-list-name)";
                              description
                                "Specify a tag to indicate priority";
                            }
    
                            leaf access-list-name {
                              type string {
                                length "1..1024";
                              }
                              must "not(../tag)";
                              description
                                "Access-list name";
                            }
                          }  // list level
                        }  // container levels
                      }  // container prefix-priority
                    }  // container spf
    
                    container maximum-redistributed-prefixes {
                      description
                        "Maximum number of redistributed prefixes";
                      leaf maximum-prefixes {
                        type uint32 {
                          range "1..28000";
                        }
                        description
                          "Maximum number of redistributed prefixes";
                      }
    
                      container levels {
                        description
                          "Set maximum redistributed prefixes for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set maximum redistributed prefixes for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set maximum redistributed prefixes for one level only";
                          }
    
                          leaf maximum-prefixes {
                            type uint32 {
                              range "1..28000";
                            }
                            mandatory true;
                            description
                              "Maximum number of redistributed prefixes";
                          }
                        }  // list level
                      }  // container levels
                    }  // container maximum-redistributed-prefixes
    
                    container propagates {
                      description
                        "Propagate routes between IS-IS levels";
                      list propagate {
                        key "level into-level";
                        description
                          "Source level";
                        leaf level {
                          type uint32 {
                            range "1..2";
                          }
                        }
    
                        leaf into-level {
                          type uint32 {
                            range "1..2";
                          }
                          description "into";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          mandatory true;
                          description
                            "Propagate only specified routes";
                        }
                      }  // list propagate
                    }  // container propagates
    
                    container adjacency-check {
                      description
                        "Suppress checking of consistent AF support on received IIHs";
                      container disable {
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable adjacency-checking";
                      }  // container disable
                    }  // container adjacency-check
    
                    container route {
                      description
                        "Control the advertisement of routes in the RIB";
                      container source {
                        description
                          "Control the path source value";
                        container first-hop {
                          presence
                            "Indicates a first-hop node is configured.";
                          description
                            "Use the IP address of the first-hop";
                        }  // container first-hop
                      }  // container source
                    }  // container route
    
                    container attached-bit {
                      description
                        "Modify behavior of the attached-bit";
                      container send {
                        description
                          "Modify how we set the attached bit";
                        container always-set {
                          must
                            "not(../never-set)";
                          presence
                            "Indicates a always-set node is configured.";
                          description
                            "Always set the attached bit in our LSP";
                        }  // container always-set
    
                        container never-set {
                          must
                            "not(../always-set)";
                          presence
                            "Indicates a never-set node is configured.";
                          description
                            "Never set the attached bit our LSP";
                        }  // container never-set
                      }  // container send
    
                      container receive {
                        description
                          "Modify how we treat received attached bits";
                        container ignore {
                          presence
                            "Indicates a ignore node is configured.";
                          description
                            "Ignore the attached bit in received LSPs";
                        }  // container ignore
                      }  // container receive
                    }  // container attached-bit
    
                    container fast-reroute {
                      description
                        "Configure Fast ReRoute";
                      leaf delay-interval {
                        type uint32 {
                          range "100..60000";
                        }
                        description
                          "Delay before running FRR computation";
                      }
    
                      container per-link {
                        when
                          "../../saf-name = 'unicast'";
                        description
                          "Prefix independent per-link computation";
                        container priority-limit {
                          description
                            "Limit backup computation upto the prefix priority";
                          container critical {
                            must
                              "not(../high or ../medium)";
                            presence
                              "Indicates a critical node is configured.";
                            description
                              "Compute for critical priority prefixes only";
                          }  // container critical
    
                          container high {
                            must
                              "not(../critical or ../medium)";
                            presence
                              "Indicates a high node is configured.";
                            description
                              "Compute for critical & high priority prefixes";
                          }  // container high
    
                          container medium {
                            must
                              "not(../critical or ../high)";
                            presence
                              "Indicates a medium node is configured.";
                            description
                              "Compute for critical, high & medium priority prefixes";
                          }  // container medium
    
                          container levels {
                            description
                              "Set priority-limit for one level only";
                            list level {
                              must
                                "critical or high or medium";
                              key "level-id";
                              description
                                "Set priority-limit for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set priority-limit for one level only";
                              }
    
                              container critical {
                                must
                                  "not(../high or ../medium)";
                                presence
                                  "Indicates a critical node is configured.";
                                description
                                  "Compute for critical priority prefixes only";
                              }  // container critical
    
                              container high {
                                must
                                  "not(../critical or ../medium)";
                                presence
                                  "Indicates a high node is configured.";
                                description
                                  "Compute for critical & high priority prefixes";
                              }  // container high
    
                              container medium {
                                must
                                  "not(../critical or ../high)";
                                presence
                                  "Indicates a medium node is configured.";
                                description
                                  "Compute for critical, high & medium priority prefixes";
                              }  // container medium
                            }  // list level
                          }  // container levels
                        }  // container priority-limit
    
                        container use-candidate-only {
                          description
                            "Exclude all interfaces from computation";
                          container candidate-only {
                            presence
                              "Indicates a use-candidate-only node is configured.";
                            description
                              "Exclude all interfaces from computation";
                          }  // container candidate-only
    
                          container levels {
                            description
                              "Exclude all interfaces for one level only";
                            list level {
                              must
                                "candidate-only";
                              key "level-id";
                              description
                                "Exclude all interfaces for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Exclude all interfaces for one level only";
                              }
    
                              container candidate-only {
                                presence
                                  "Indicates a use-candidate-only node is configured.";
                                description
                                  "Exclude all interfaces from computation";
                              }  // container candidate-only
                            }  // list level
                          }  // container levels
                        }  // container use-candidate-only
                      }  // container per-link
    
                      container per-prefix {
                        when
                          "../../saf-name = 'unicast'";
                        description
                          "Prefix dependent computation";
                        container priority-limit {
                          description
                            "Limit backup computation upto the prefix priority";
                          container critical {
                            must
                              "not(../high or ../medium)";
                            presence
                              "Indicates a critical node is configured.";
                            description
                              "Compute for critical priority prefixes only";
                          }  // container critical
    
                          container high {
                            must
                              "not(../critical or ../medium)";
                            presence
                              "Indicates a high node is configured.";
                            description
                              "Compute for critical & high priority prefixes";
                          }  // container high
    
                          container medium {
                            must
                              "not(../critical or ../high)";
                            presence
                              "Indicates a medium node is configured.";
                            description
                              "Compute for critical, high & medium priority prefixes";
                          }  // container medium
    
                          container levels {
                            description
                              "Set priority-limit for one level only";
                            list level {
                              must
                                "critical or high or medium";
                              key "level-id";
                              description
                                "Set priority-limit for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set priority-limit for one level only";
                              }
    
                              container critical {
                                must
                                  "not(../high or ../medium)";
                                presence
                                  "Indicates a critical node is configured.";
                                description
                                  "Compute for critical priority prefixes only";
                              }  // container critical
    
                              container high {
                                must
                                  "not(../critical or ../medium)";
                                presence
                                  "Indicates a high node is configured.";
                                description
                                  "Compute for critical & high priority prefixes";
                              }  // container high
    
                              container medium {
                                must
                                  "not(../critical or ../high)";
                                presence
                                  "Indicates a medium node is configured.";
                                description
                                  "Compute for critical, high & medium priority prefixes";
                              }  // container medium
                            }  // list level
                          }  // container levels
                        }  // container priority-limit
    
                        container use-candidate-only {
                          description
                            "Exclude all interfaces from computation";
                          container candidate-only {
                            presence
                              "Indicates a use-candidate-only node is configured.";
                            description
                              "Exclude all interfaces from computation";
                          }  // container candidate-only
    
                          container levels {
                            description
                              "Exclude all interfaces for one level only";
                            list level {
                              must
                                "candidate-only";
                              key "level-id";
                              description
                                "Exclude all interfaces for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Exclude all interfaces for one level only";
                              }
    
                              container candidate-only {
                                presence
                                  "Indicates a use-candidate-only node is configured.";
                                description
                                  "Exclude all interfaces from computation";
                              }  // container candidate-only
                            }  // list level
                          }  // container levels
                        }  // container use-candidate-only
    
                        container tiebreaker {
                          description
                            "Configure tiebreaker for multiple backups";
                          container downstream {
                            description
                              "Prefer backup path via downstream node";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container downstream
    
                          container lc-disjoint {
                            description
                              "Prefer line card disjoint backup path";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container lc-disjoint
    
                          container lowest-backup-metric {
                            description
                              "Prefer backup path with lowest total metric";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container lowest-backup-metric
    
                          container node-protecting {
                            description
                              "Prefer node protecting backup path";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container node-protecting
    
                          container primary-path {
                            description
                              "Prefer backup path from ECMP set";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container primary-path
    
                          container secondary-path {
                            description
                              "Prefer non-ECMP backup path";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container secondary-path
    
                          container srlg-disjoint {
                            description
                              "Prefer SRLG disjoint backup path";
                            leaf index {
                              type uint32 {
                                range "1..255";
                              }
                              description
                                "Set preference order among tiebreakers";
                            }
    
                            container levels {
                              description
                                "Configure tiebreaker for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Configure tiebreaker for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure tiebreaker for one level only";
                                }
    
                                leaf index {
                                  type uint32 {
                                    range
                                      "1..255";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Set preference order among tiebreakers";
                                }
                              }  // list level
                            }  // container levels
                          }  // container srlg-disjoint
                        }  // container tiebreaker
    
                        container load-sharing {
                          description
                            "Load share prefixes across multiple backups";
                          container disable {
                            presence
                              "Indicates a disable node is configured.";
                            description
                              "Disable load sharing";
                          }  // container disable
    
                          container levels {
                            description
                              "Disable load sharing for one level only";
                            list level {
                              must "disable";
                              key "level-id";
                              description
                                "Disable load sharing for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Disable load sharing for one level only";
                              }
    
                              container disable {
                                presence
                                  "Indicates a disable node is configured.";
                                description
                                  "Disable load sharing";
                              }  // container disable
                            }  // list level
                          }  // container levels
                        }  // container load-sharing
    
                        container remote-lfa {
                          description
                            "Enable remote LFA related configuration";
                          container prefix-list {
                            description
                              "Filter PQ node router ID based on prefix list";
                            leaf prefix-list-name {
                              type xr:Cisco-ios-xr-string {
                                length "1..1024";
                              }
                              description
                                "Filter PQ node router ID based on prefix list";
                            }
    
                            container levels {
                              description
                                "Enable router ID filtering for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Enable router ID filtering for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Enable router ID filtering for one level only";
                                }
    
                                leaf prefix-list-name {
                                  type string {
                                    length
                                      "1..1024";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Filter PQ node router ID based on prefix list";
                                }
                              }  // list level
                            }  // container levels
                          }  // container prefix-list
                        }  // container remote-lfa
    
                        container srlg-protection {
                          description
                            "Type of SRLG protection";
                          container weighted-global {
                            presence
                              "Indicates a weighted-global node is configured.";
                            description
                              "Weighted global SRLG protection";
                          }  // container weighted-global
    
                          container levels {
                            description
                              "Set SRLG protection type for one level only";
                            list level {
                              must
                                "weighted-global";
                              key "level-id";
                              description
                                "Set SRLG protection type for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set SRLG protection type for one level only";
                              }
    
                              container weighted-global {
                                presence
                                  "Indicates a weighted-global node is configured.";
                                description
                                  "Weighted global SRLG protection";
                              }  // container weighted-global
                            }  // list level
                          }  // container levels
                        }  // container srlg-protection
                      }  // container per-prefix
                    }  // container fast-reroute
    
                    container monitor-convergence {
                      presence
                        "Indicates a monitor-convergence node is configured.";
                      description
                        "Enables convergence monitoring";
                      leaf prefix-list {
                        type xr:Cisco-ios-xr-string {
                          length "1..1024";
                        }
                        description
                          "Enables Individual Prefix Monitoring";
                      }
    
                      container track-ip-frr {
                        presence
                          "Indicates a track-ip-frr node is configured.";
                        description
                          "Enables Tracking IP-Frr Convergence";
                      }  // container track-ip-frr
                    }  // container monitor-convergence
    
                    container mpls {
                      description
                        "Configure MPLS routing protocol parameters";
                      container ldp {
                        description
                          "Configure LDP parameters";
                        container auto-config {
                          presence
                            "Indicates a auto-config node is configured.";
                          description
                            "Enable LDP IGP interface auto-configuration";
                        }  // container auto-config
                      }  // container ldp
    
                      container traffic-eng {
                        description
                          "Routing protocol commands for MPLS Traffic Engineering";
                        container router-id {
                          description
                            "Traffic Engineering stable IP address for system";
                          leaf ip-address {
                            type inet:ipv4-address-no-zone;
                            description
                              "configure this node";
                          }
    
                          leaf interface {
                            type xr:Interface-name;
                            description "";
                          }
                        }  // container router-id
    
                        container igp-intact {
                          presence
                            "Indicates a igp-intact node is configured.";
                          description
                            "Install both TE and non-TE nexthops in the RIB.";
                        }  // container igp-intact
    
                        container multicast-intact {
                          presence
                            "Indicates a multicast-intact node is configured.";
                          description
                            "Install non-TE nexthops in the RIB for use by multicast";
                        }  // container multicast-intact
    
                        container level-1-2 {
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Enable mpls traffic-eng at both level 1 and 2";
                        }  // container level-1-2
    
                        container level-1 {
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Enable mpls traffic-eng at level 1";
                        }  // container level-1
    
                        container level-2-only {
                          presence
                            "Indicates a level-2-only node is configured.";
                          description
                            "Enable mpls traffic-eng at level 2";
                        }  // container level-2-only
    
                        container tunnel {
                          description
                            "Tunnel selection";
                          container restricted {
                            presence
                              "Indicates a restricted node is configured.";
                            description
                              "Use only primary tunnel for destination IP address";
                          }  // container restricted
    
                          container preferred {
                            presence
                              "Indicates a preferred node is configured.";
                            description
                              "Prefer TE tunnels over equal-cost physical paths";
                          }  // container preferred
    
                          container metric {
                            description
                              "Default metric for forwarding-adjacency tunnels";
                            leaf default-metric {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              description
                                "Default metric for forwarding-adjacency tunnels";
                            }
    
                            container levels {
                              description
                                "Set metric for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Set metric for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Set metric for one level only";
                                }
    
                                leaf default-metric {
                                  type uint32 {
                                    range
                                      "1..16777214";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Default metric for forwarding-adjacency tunnels";
                                }
                              }  // list level
                            }  // container levels
                          }  // container metric
                        }  // container tunnel
                      }  // container traffic-eng
                    }  // container mpls
    
                    container single-topology {
                      when
                        "../af-name = 'ipv6' and ../saf-name = 'unicast'";
                      presence
                        "Indicates a single-topology node is configured.";
                      description
                        "Run IPv6 Unicast using the standard (IPv4 Unicast) topology";
                    }  // container single-topology
                  }  // list address-family
    
                  list address-family-topology {
                    key "af-name saf-name topology-name";
                    description
                      "IS-IS address family with a non-default topology";
                    leaf af-name {
                      type Isis-af-name;
                      description
                        "Address family name";
                    }
    
                    leaf saf-name {
                      type Isis-saf-multicast;
                      description
                        "Sub address family name";
                    }
    
                    leaf topology-name {
                      type string {
                        length "1..32";
                      }
                      description
                        "Specify a non-default topology";
                    }
    
                    container default-information {
                      description
                        "Control distribution of default information";
                      container originate {
                        presence
                          "Indicates a originate node is configured.";
                        description
                          "Distribute a default route";
                        container external {
                          presence
                            "Indicates a external node is configured.";
                          description
                            "Originate default prefix as an external route";
                        }  // container external
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
                      }  // container originate
                    }  // container default-information
    
                    container segment-routing {
                      description
                        "Enable Segment Routing";
                      container mpls {
                        description
                          "Enable Segment Routing using MPLS encapsulation";
                        container connected-prefix-sid-map {
                          presence
                            "Indicates a connected-prefix-sid-map node is configured.";
                          description
                            "Enter connected prefix sid map submode";
                        }  // container connected-prefix-sid-map
                      }  // container mpls
                    }  // container segment-routing
    
                    container distance {
                      description
                        "Configure IS-IS administrative distances";
                      leaf global-administrative-distance {
                        type uint32 {
                          range "1..255";
                        }
                        description
                          "Configure IS-IS administrative distances";
                      }
    
                      container route-sources {
                        description
                          "Route source for this distance";
                        list route-source {
                          key "address-prefix";
                          description
                            "Route source for this distance";
                          leaf address-prefix {
                            type inet:ip-prefix;
                            description
                              "Route source for this distance";
                          }
    
                          leaf administrative-distance {
                            type uint32 {
                              range "1..255";
                            }
                            description
                              "Configure IS-IS administrative distances";
                          }
    
                          leaf prefix-access-list {
                            type string {
                              length "1..1024";
                            }
                            description
                              "Prefix-list or access-list to filter routes for this distance";
                          }
                        }  // list route-source
                      }  // container route-sources
                    }  // container distance
    
                    container distribute-list {
                      description
                        "Filter routes sent to the RIB";
                      leaf prefix-list {
                        type xr:Cisco-ios-xr-string {
                          length "1..1024";
                        }
                        description
                          "Filter routes based on a prefix list";
                      }
    
                      leaf route-policy {
                        type xr:Route-policy-name;
                        description
                          "Filter routes based on a route policy";
                      }
                    }  // container distribute-list
    
                    container redistribute {
                      description
                        "Redistribute information from another routing protocol";
                      container connected {
                        presence
                          "Indicates a connected node is configured.";
                        description
                          "Connected routes";
                        container level-1-2 {
                          must
                            "not(../level-1) and not(../level-2)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container connected
    
                      list ospf {
                        when
                          "../../af-name = 'ipv4'";
                        key "process-id";
                        description
                          "Open Shortest Path First (OSPF)";
                        leaf process-id {
                          type string {
                            length "1..1024";
                          }
                          description
                            "Open Shortest Path First (OSPF)";
                        }
    
                        container match {
                          description
                            "Redistribution of OSPF routes";
                          container internal {
                            must
                              "not(../external or ../nssa-external)";
                            presence
                              "Indicates a internal node is configured.";
                            description
                              "Redistribute OSPF internal routes";
                          }  // container internal
    
                          container external {
                            must
                              "not(../internal or ../nssa-external)";
                            presence
                              "Indicates a external node is configured.";
                            description
                              "Redistribute OSPF external routes";
                          }  // container external
    
                          container nssa-external {
                            must
                              "not(../internal or ../external)";
                            presence
                              "Indicates a nssa-external node is configured.";
                            description
                              "Redistribute OSPF NSSA external routes";
                          }  // container nssa-external
                        }  // container match
    
                        container level-1-2 {
                          must
                            "not(../level-1) and not(../level-2)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // list ospf
    
                      list ospfv3 {
                        when
                          "../../af-name = 'ipv6'";
                        key "process-id";
                        description
                          "Open Shortest Path First (OSPFv3)";
                        leaf process-id {
                          type string {
                            length "1..1024";
                          }
                          description
                            "Open Shortest Path First (OSPFv3)";
                        }
    
                        container match {
                          description
                            "Redistribution of OSPF routes";
                          container internal {
                            must
                              "not(../external or ../nssa-external)";
                            presence
                              "Indicates a internal node is configured.";
                            description
                              "Redistribute OSPF internal routes";
                          }  // container internal
    
                          container external {
                            must
                              "not(../internal or ../nssa-external)";
                            presence
                              "Indicates a external node is configured.";
                            description
                              "Redistribute OSPF external routes";
                          }  // container external
    
                          container nssa-external {
                            must
                              "not(../internal or ../external)";
                            presence
                              "Indicates a nssa-external node is configured.";
                            description
                              "Redistribute OSPF NSSA external routes";
                          }  // container nssa-external
                        }  // container match
    
                        container level-1-2 {
                          must
                            "not(../level-1) and not(../level-2)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // list ospfv3
    
                      container static {
                        presence
                          "Indicates a static node is configured.";
                        description
                          "Static routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container static
    
                      container subscriber {
                        presence
                          "Indicates a subscriber node is configured.";
                        description
                          "Subscriber routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container subscriber
    
                      container rip {
                        presence
                          "Indicates a rip node is configured.";
                        description "RIP routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container rip
    
                      container mobile {
                        presence
                          "Indicates a mobile node is configured.";
                        description
                          "Mobile routes";
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // container mobile
    
                      container applications {
                        description
                          "Application routes";
                        list application {
                          key "application-name";
                          description
                            "Application routes";
                          leaf application-name {
                            type string {
                              length "1..1024";
                            }
                            description
                              "Application routes";
                          }
    
                          container level-1-2 {
                            must
                              "not(../level-2) and not(../level-1)";
                            presence
                              "Indicates a level-1-2 node is configured.";
                            description
                              "Redistribute routes into both levels";
                          }  // container level-1-2
    
                          container level-2 {
                            must
                              "not(../level-1-2) and not(../level-1)";
                            presence
                              "Indicates a level-2 node is configured.";
                            description
                              "Redistribute routes into level 2 only (the default)";
                          }  // container level-2
    
                          container level-1 {
                            must
                              "not(../level-1-2) and not(../level-2)";
                            presence
                              "Indicates a level-1 node is configured.";
                            description
                              "Redistribute routes into level 1 only";
                          }  // container level-1
    
                          leaf metric {
                            type uint32 {
                              range
                                "0..16777215";
                            }
                            description
                              "Metric for redistributed routes";
                          }
    
                          leaf route-policy {
                            type xr:Route-policy-name;
                            description
                              "Route policy reference";
                          }
    
                          leaf metric-type {
                            type enumeration {
                              enum "internal" {
                                value 0;
                                description
                                  "Set IS-IS Internal metric type";
                              }
                              enum "external" {
                                value 1;
                                description
                                  "Set IS-IS External metric type";
                              }
                              enum
                                "rib-metric-as-internal" {
                                value 2;
                                description
                                  "Set IS-IS Internal metric type and use RIB metric";
                              }
                              enum
                                "rib-metric-as-external" {
                                value 3;
                                description
                                  "Set IS-IS External metric type and use RIB metric";
                              }
                            }
                            description
                              "IS-IS metric type for redistributed routes";
                          }
                        }  // list application
                      }  // container applications
    
                      list isis {
                        key "instance-id";
                        description "IS-IS";
                        leaf instance-id {
                          type string {
                            length "1..1024";
                          }
                          description "IS-IS";
                        }
    
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
    
                        container down-flag-clear {
                          presence
                            "Indicates a down-flag-clear node is configured.";
                          description
                            "Set the up/down bit to 0 in prefix advertisements";
                        }  // container down-flag-clear
                      }  // list isis
    
                      container bgp {
                        description
                          "Border Gateway Protocol (BGP)";
                        list as {
                          key "as-number";
                          description
                            "bgp as-number";
                          leaf as-number {
                            type xr:Bgp-as-number;
                            description
                              "bgp as-number";
                          }
    
                          container level-1-2 {
                            must
                              "not(../level-2) and not(../level-1)";
                            presence
                              "Indicates a level-1-2 node is configured.";
                            description
                              "Redistribute routes into both levels";
                          }  // container level-1-2
    
                          container level-2 {
                            must
                              "not(../level-1-2) and not(../level-1)";
                            presence
                              "Indicates a level-2 node is configured.";
                            description
                              "Redistribute routes into level 2 only (the default)";
                          }  // container level-2
    
                          container level-1 {
                            must
                              "not(../level-1-2) and not(../level-2)";
                            presence
                              "Indicates a level-1 node is configured.";
                            description
                              "Redistribute routes into level 1 only";
                          }  // container level-1
    
                          leaf metric {
                            type uint32 {
                              range
                                "0..16777215";
                            }
                            description
                              "Metric for redistributed routes";
                          }
    
                          leaf route-policy {
                            type xr:Route-policy-name;
                            description
                              "Route policy reference";
                          }
    
                          leaf metric-type {
                            type enumeration {
                              enum "internal" {
                                value 0;
                                description
                                  "Set IS-IS Internal metric type";
                              }
                              enum "external" {
                                value 1;
                                description
                                  "Set IS-IS External metric type";
                              }
                              enum
                                "rib-metric-as-internal" {
                                value 2;
                                description
                                  "Set IS-IS Internal metric type and use RIB metric";
                              }
                              enum
                                "rib-metric-as-external" {
                                value 3;
                                description
                                  "Set IS-IS External metric type and use RIB metric";
                              }
                            }
                            description
                              "IS-IS metric type for redistributed routes";
                          }
                        }  // list as
                      }  // container bgp
    
                      list eigrp {
                        key "as-number";
                        description
                          "EIGRP Protocol";
                        leaf as-number {
                          type uint32 {
                            range "1..65535";
                          }
                          description
                            "EIGRP Protocol";
                        }
    
                        container match {
                          description
                            "Redistribution of EIGRP routes";
                          container internal {
                            must
                              "not(../external)";
                            presence
                              "Indicates a internal node is configured.";
                            description
                              "Redistribute EIGRP internal routes";
                          }  // container internal
    
                          container external {
                            must
                              "not(../internal)";
                            presence
                              "Indicates a external node is configured.";
                            description
                              "Redistribute EIGRP external routes";
                          }  // container external
                        }  // container match
    
                        container level-1-2 {
                          must
                            "not(../level-2) and not(../level-1)";
                          presence
                            "Indicates a level-1-2 node is configured.";
                          description
                            "Redistribute routes into both levels";
                        }  // container level-1-2
    
                        container level-2 {
                          must
                            "not(../level-1-2) and not(../level-1)";
                          presence
                            "Indicates a level-2 node is configured.";
                          description
                            "Redistribute routes into level 2 only (the default)";
                        }  // container level-2
    
                        container level-1 {
                          must
                            "not(../level-1-2) and not(../level-2)";
                          presence
                            "Indicates a level-1 node is configured.";
                          description
                            "Redistribute routes into level 1 only";
                        }  // container level-1
    
                        leaf metric {
                          type uint32 {
                            range "0..16777215";
                          }
                          description
                            "Metric for redistributed routes";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          description
                            "Route policy reference";
                        }
    
                        leaf metric-type {
                          type enumeration {
                            enum "internal" {
                              value 0;
                              description
                                "Set IS-IS Internal metric type";
                            }
                            enum "external" {
                              value 1;
                              description
                                "Set IS-IS External metric type";
                            }
                            enum
                              "rib-metric-as-internal" {
                              value 2;
                              description
                                "Set IS-IS Internal metric type and use RIB metric";
                            }
                            enum
                              "rib-metric-as-external" {
                              value 3;
                              description
                                "Set IS-IS External metric type and use RIB metric";
                            }
                          }
                          description
                            "IS-IS metric type for redistributed routes";
                        }
                      }  // list eigrp
                    }  // container redistribute
    
                    leaf maximum-paths {
                      type uint32 {
                        range "1..64";
                      }
                      description
                        "Maximum number of active parallel paths per route";
                    }
    
                    container advertise {
                      description
                        "Control what we advertise in our LSP";
                      container passive-only {
                        presence
                          "Indicates a passive-only node is configured.";
                        description
                          "Advertise prefixes of passive interfaces only";
                      }  // container passive-only
    
                      container link {
                        description
                          "IS Neighbor attributes";
                        container attributes {
                          presence
                            "Indicates a attributes node is configured.";
                          description
                            "Advertise additional link attributes";
                        }  // container attributes
                      }  // container link
    
                      container application {
                        description
                          "Application Specific Data";
                        container lfa {
                          description
                            "LFA Application";
                          container link-attributes {
                            description
                              "Application Specific Link Attributes";
                            container srlg {
                              presence
                                "Indicates a srlg node is configured.";
                              description
                                "Shared Risk Ling Group";
                            }  // container srlg
                          }  // container link-attributes
                        }  // container lfa
    
                        container flex-algo {
                          description
                            "Flex-Algo Application";
                          container link-attributes {
                            description
                              "Application Specific Link Attributes";
                            container srlg {
                              presence
                                "Indicates a srlg node is configured.";
                              description
                                "Shared Risk Ling Group";
                            }  // container srlg
                          }  // container link-attributes
                        }  // container flex-algo
                      }  // container application
                    }  // container advertise
    
                    container ucmp {
                      description
                        "UnEqual Cost Multipath feature";
                      container variance {
                        presence
                          "Indicates a variance node is configured.";
                        description
                          "Specify Variance parameter to filter UCMP paths based on cost";
                        leaf variance-value {
                          type uint32 {
                            range "101..10000";
                          }
                          mandatory true;
                          description
                            "Specify Variance parameter to filter UCMP paths based on cost";
                        }
    
                        leaf prefix-list {
                          type string {
                            length "1..1024";
                          }
                          description
                            "Specify prefix-list name to filter UCMP paths based on prefixes";
                        }
                      }  // container variance
    
                      container exclude {
                        description
                          "UCMP interface exclusion information";
                        container interfaces {
                          description
                            "Exclude an interface from UCMP computation";
                          list interface {
                            key "interface-name";
                            description
                              "Exclude an interface from UCMP computation";
                            leaf interface-name {
                              type xr:Interface-name;
                              description
                                "Exclude an interface from UCMP computation";
                            }
                          }  // list interface
                        }  // container interfaces
                      }  // container exclude
    
                      leaf delay-interval {
                        type uint32 {
                          range "100..65535";
                        }
                        description
                          "UCMP delay interval";
                      }
                    }  // container ucmp
    
                    container microloop {
                      description
                        "Enable microloop protection feature";
                      container avoidance {
                        presence
                          "Indicates a avoidance node is configured.";
                        description
                          "Enable local microloop avoidance";
                        container protected {
                          must
                            "not(../segment-routing)";
                          presence
                            "Indicates a protected node is configured.";
                          description
                            "Enable microloop avoidance for only protected prefixes";
                        }  // container protected
    
                        container segment-routing {
                          must
                            "not(../protected)";
                          presence
                            "Indicates a segment-routing node is configured.";
                          description
                            "Enable segment routing microloop avoidance ";
                        }  // container segment-routing
                      }  // container avoidance
    
                      leaf avoidance-rib-update-delay {
                        type uint32 {
                          range "1000..65535";
                        }
                        description
                          "Delay in milliseconds";
                      }
                    }  // container microloop
    
                    container apply-weight {
                      description "Apply weight";
                      container ecmp-only {
                        must "not(../ucmp-only)";
                        presence
                          "Indicates a ecmp-only node is configured.";
                        description
                          "Apply weights to ecmp paths only";
                        container bandwidth {
                          presence
                            "Indicates a bandwidth node is configured.";
                          description
                            "Apply weight calculated based on interface bandwidth";
                        }  // container bandwidth
                      }  // container ecmp-only
    
                      container ucmp-only {
                        must "not(../ecmp-only)";
                        presence
                          "Indicates a ucmp-only node is configured.";
                        description
                          "Apply weights to ucmp paths only";
                      }  // container ucmp-only
                    }  // container apply-weight
    
                    container summary-prefixes {
                      description
                        "Configure IP address prefixes";
                      list summary-prefix {
                        key "address-prefix";
                        description
                          "Summary prefix";
                        leaf address-prefix {
                          type inet:ip-prefix;
                          description
                            "Specify prefix associated with this Prefix Segement ID";
                        }
    
                        leaf tag {
                          type uint32 {
                            range
                              "1..4294967295";
                          }
                          description
                            "Set a tag";
                        }
    
                        leaf level {
                          type uint32 {
                            range "1..2";
                          }
                          description
                            "Summarize routes in one level only";
                        }
    
                        leaf algorithm {
                          when
                            "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'";
                          type uint32 {
                            range "128..255";
                          }
                          description
                            "Flexible Algorithm number";
                        }
    
                        container explicit {
                          when
                            "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'";
                          presence
                            "Indicates a explicit node is configured.";
                          description
                            "Strict flex-algo locator summarization mode";
                        }  // container explicit
                      }  // list summary-prefix
                    }  // container summary-prefixes
    
                    container metric {
                      description
                        "Configure default metric";
                      container default-metric {
                        description
                          "Default metric: <1-63> for narrow, <1-16777214> for wide";
                        leaf default-metric-value {
                          type uint32 {
                            range "1..16777214";
                          }
                          description
                            "Default metric: <1-63> for narrow, <1-16777214> for wide";
                        }
    
                        container levels {
                          description
                            "Set metric for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set metric for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set metric for one level only";
                            }
    
                            leaf default-metric-value {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              mandatory true;
                              description
                                "Default metric: <1-63> for narrow, <1-16777214> for wide";
                            }
                          }  // list level
                        }  // container levels
                      }  // container default-metric
                    }  // container metric
    
                    container metric-style {
                      description
                        "Use old-style (ISO 10589) or new-style packet formats";
                      container narrow {
                        must
                          "not(../wide or ../transition)";
                        presence
                          "Indicates a narrow node is configured.";
                        description
                          "Use old style of TLVs with narrow metric";
                      }  // container narrow
    
                      container wide {
                        must
                          "not(../narrow or ../transition)";
                        presence
                          "Indicates a wide node is configured.";
                        description
                          "Use new style of TLVs to carry wider metric";
                      }  // container wide
    
                      container transition {
                        must
                          "not(../narrow or ../wide)";
                        presence
                          "Indicates a transition node is configured.";
                        description
                          "Send and accept both styles of TLVs during transition";
                      }  // container transition
    
                      container levels {
                        description
                          "Set metric-style for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set metric-style for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set metric-style for one level only";
                          }
    
                          container narrow {
                            must
                              "not(../wide or ../transition)";
                            presence
                              "Indicates a narrow node is configured.";
                            description
                              "Use old style of TLVs with narrow metric";
                          }  // container narrow
    
                          container wide {
                            must
                              "not(../narrow or ../transition)";
                            presence
                              "Indicates a wide node is configured.";
                            description
                              "Use new style of TLVs to carry wider metric";
                          }  // container wide
    
                          container transition {
                            must
                              "not(../narrow or ../wide)";
                            presence
                              "Indicates a transition node is configured.";
                            description
                              "Send and accept both styles of TLVs during transition";
                          }  // container transition
                        }  // list level
                      }  // container levels
                    }  // container metric-style
    
                    container spf-interval {
                      description
                        "Route calculation scheduling parameters (FSPF, ISPF, PRC)";
                      container maximum-wait {
                        description
                          "Maximum delay before running a route calculation";
                        leaf maximum-wait-time {
                          type uint32 {
                            range "0..120000";
                          }
                          description
                            "Maximum delay before running a route calculation";
                        }
    
                        container levels {
                          description
                            "Set SPF interval for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set SPF interval for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set SPF interval for one level only";
                            }
    
                            leaf maximum-wait-time {
                              type uint32 {
                                range
                                  "0..120000";
                              }
                              mandatory true;
                              description
                                "Maximum delay before running a route calculation";
                            }
                          }  // list level
                        }  // container levels
                      }  // container maximum-wait
    
                      container initial-wait {
                        description
                          "Initial delay before running a route calculation";
                        leaf initial-wait-time {
                          type uint32 {
                            range "0..120000";
                          }
                          description
                            "Initial delay before running a route calculation";
                        }
    
                        container levels {
                          description
                            "Set SPF interval for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set SPF interval for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set SPF interval for one level only";
                            }
    
                            leaf initial-wait-time {
                              type uint32 {
                                range
                                  "0..120000";
                              }
                              mandatory true;
                              description
                                "Initial delay before running a route calculation";
                            }
                          }  // list level
                        }  // container levels
                      }  // container initial-wait
    
                      container secondary-wait {
                        description
                          "Secondary delay before running a route calculation";
                        leaf secondary-wait-time {
                          type uint32 {
                            range "0..120000";
                          }
                          description
                            "Secondary delay before running a route calculation";
                        }
    
                        container levels {
                          description
                            "Set SPF interval for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set SPF interval for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set SPF interval for one level only";
                            }
    
                            leaf secondary-wait-time {
                              type uint32 {
                                range
                                  "0..120000";
                              }
                              mandatory true;
                              description
                                "Secondary delay before running a route calculation";
                            }
                          }  // list level
                        }  // container levels
                      }  // container secondary-wait
                    }  // container spf-interval
    
                    container spf {
                      description
                        "SPF configuration";
                      container periodic {
                        description
                          "Configure the periodic SPF";
                        container interval {
                          description
                            "Set the maximum interval in between SPF runs";
                          leaf interval-time {
                            type uint32 {
                              range "1..3600";
                            }
                            description
                              "Set the maximum interval in between SPF runs";
                          }
    
                          container levels {
                            description
                              "Configure periodic SPF interval for for one level only";
                            list level {
                              key "level-id";
                              description
                                "Configure periodic SPF interval for for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Configure periodic SPF interval for for one level only";
                              }
    
                              leaf interval-time {
                                type uint32 {
                                  range
                                    "1..3600";
                                }
                                mandatory true;
                                description
                                  "Set the maximum interval in between SPF runs";
                              }
                            }  // list level
                          }  // container levels
                        }  // container interval
    
                        container disable {
                          description
                            "Disable the periodic SPF";
                          container disable-periodic-spf {
                            presence
                              "Indicates a disable node is configured.";
                            description
                              "Disable the periodic SPF";
                          }  // container disable-periodic-spf
    
                          container levels {
                            description
                              "Configure periodic SPF interval for for one level only";
                            list level {
                              must
                                "disable-periodic-spf";
                              key "level-id";
                              description
                                "Configure periodic SPF interval for for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Configure periodic SPF interval for for one level only";
                              }
    
                              container disable-periodic-spf {
                                presence
                                  "Indicates a disable node is configured.";
                                description
                                  "Disable the periodic SPF";
                              }  // container disable-periodic-spf
                            }  // list level
                          }  // container levels
                        }  // container disable
                      }  // container periodic
    
                      container prefix-priority {
                        description
                          "Configure a prefix priority list";
                        list prefix-priority {
                          must
                            "tag or access-list-name";
                          key "priority";
                          description
                            "Configure a prefix priority list";
                          leaf priority {
                            type enumeration {
                              enum "critical" {
                                value 0;
                                description
                                  "Specify critical priority prefixes";
                              }
                              enum "high" {
                                value 1;
                                description
                                  "Specify high priority prefixes";
                              }
                              enum "medium" {
                                value 2;
                                description
                                  "Specify medium priority prefixes";
                              }
                            }
                            description
                              "prefix priority";
                          }
    
                          leaf tag {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            must
                              "not(../access-list-name)";
                            description
                              "Specify a tag to indicate priority";
                          }
    
                          leaf access-list-name {
                            type string {
                              length "1..1024";
                            }
                            must "not(../tag)";
                            description
                              "Access-list name";
                          }
                        }  // list prefix-priority
    
                        container levels {
                          description
                            "Configure SPF prefix priority list for one level only";
                          list level {
                            must
                              "tag or access-list-name";
                            key "level-id priority";
                            description
                              "Configure SPF prefix priority list for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Configure SPF prefix priority list for one level only";
                            }
    
                            leaf priority {
                              type enumeration {
                                enum "critical" {
                                  value 0;
                                  description
                                    "Specify critical priority prefixes";
                                }
                                enum "high" {
                                  value 1;
                                  description
                                    "Specify high priority prefixes";
                                }
                                enum "medium" {
                                  value 2;
                                  description
                                    "Specify medium priority prefixes";
                                }
                              }
                              description
                                "prefix priority";
                            }
    
                            leaf tag {
                              type uint32 {
                                range
                                  "1..4294967295";
                              }
                              must
                                "not(../access-list-name)";
                              description
                                "Specify a tag to indicate priority";
                            }
    
                            leaf access-list-name {
                              type string {
                                length "1..1024";
                              }
                              must "not(../tag)";
                              description
                                "Access-list name";
                            }
                          }  // list level
                        }  // container levels
                      }  // container prefix-priority
                    }  // container spf
    
                    container maximum-redistributed-prefixes {
                      description
                        "Maximum number of redistributed prefixes";
                      leaf maximum-prefixes {
                        type uint32 {
                          range "1..28000";
                        }
                        description
                          "Maximum number of redistributed prefixes";
                      }
    
                      container levels {
                        description
                          "Set maximum redistributed prefixes for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set maximum redistributed prefixes for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set maximum redistributed prefixes for one level only";
                          }
    
                          leaf maximum-prefixes {
                            type uint32 {
                              range "1..28000";
                            }
                            mandatory true;
                            description
                              "Maximum number of redistributed prefixes";
                          }
                        }  // list level
                      }  // container levels
                    }  // container maximum-redistributed-prefixes
    
                    container propagates {
                      description
                        "Propagate routes between IS-IS levels";
                      list propagate {
                        key "level into-level";
                        description
                          "Source level";
                        leaf level {
                          type uint32 {
                            range "1..2";
                          }
                        }
    
                        leaf into-level {
                          type uint32 {
                            range "1..2";
                          }
                          description "into";
                        }
    
                        leaf route-policy {
                          type xr:Route-policy-name;
                          mandatory true;
                          description
                            "Propagate only specified routes";
                        }
                      }  // list propagate
                    }  // container propagates
    
                    container adjacency-check {
                      description
                        "Suppress checking of consistent AF support on received IIHs";
                      container disable {
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable adjacency-checking";
                      }  // container disable
                    }  // container adjacency-check
    
                    container route {
                      description
                        "Control the advertisement of routes in the RIB";
                      container source {
                        description
                          "Control the path source value";
                        container first-hop {
                          presence
                            "Indicates a first-hop node is configured.";
                          description
                            "Use the IP address of the first-hop";
                        }  // container first-hop
                      }  // container source
                    }  // container route
    
                    container attached-bit {
                      description
                        "Modify behavior of the attached-bit";
                      container send {
                        description
                          "Modify how we set the attached bit";
                        container always-set {
                          must
                            "not(../never-set)";
                          presence
                            "Indicates a always-set node is configured.";
                          description
                            "Always set the attached bit in our LSP";
                        }  // container always-set
    
                        container never-set {
                          must
                            "not(../always-set)";
                          presence
                            "Indicates a never-set node is configured.";
                          description
                            "Never set the attached bit our LSP";
                        }  // container never-set
                      }  // container send
    
                      container receive {
                        description
                          "Modify how we treat received attached bits";
                        container ignore {
                          presence
                            "Indicates a ignore node is configured.";
                          description
                            "Ignore the attached bit in received LSPs";
                        }  // container ignore
                      }  // container receive
                    }  // container attached-bit
    
                    leaf topology-id {
                      type uint32 {
                        range "6..4095";
                      }
                      description
                        "Specify the IS-IS MT ID for this topology";
                    }
    
                    container fast-reroute {
                      description
                        "Configure Fast ReRoute";
                      leaf delay-interval {
                        type uint32 {
                          range "100..60000";
                        }
                        description
                          "Delay before running FRR computation";
                      }
                    }  // container fast-reroute
    
                    container monitor-convergence {
                      presence
                        "Indicates a monitor-convergence node is configured.";
                      description
                        "Enables convergence monitoring";
                      leaf prefix-list {
                        type xr:Cisco-ios-xr-string {
                          length "1..1024";
                        }
                        description
                          "Enables Individual Prefix Monitoring";
                      }
    
                      container track-ip-frr {
                        presence
                          "Indicates a track-ip-frr node is configured.";
                        description
                          "Enables Tracking IP-Frr Convergence";
                      }  // container track-ip-frr
                    }  // container monitor-convergence
                  }  // list address-family-topology
                }  // container address-families
    
                container interfaces {
                  description
                    "Enter the IS-IS interface configuration submode";
                  list interface {
                    key "interface-name";
                    description
                      "Enter the IS-IS interface configuration submode";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Enter the IS-IS interface configuration submode";
                    }
    
                    leaf circuit-type {
                      type enumeration {
                        enum "level-1" {
                          value 1;
                          description
                            "Form level-1 adjacencies only";
                        }
                        enum "level-2-only" {
                          value 2;
                          description
                            "Form level-2 adjacencies only";
                        }
                        enum "level-1-2" {
                          value 3;
                          description
                            "Form level-1 and level-2 adjacencies";
                        }
                      }
                      description
                        "Configure circuit type for interface";
                    }
    
                    container csnp-interval {
                      description
                        "Set CSNP interval";
                      leaf csnp-interval-time {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Set CSNP interval";
                      }
    
                      container levels {
                        description
                          "Set the CSNP interval only at the supplied level";
                        list level {
                          key "level-id";
                          description
                            "Set the CSNP interval only at the supplied level";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set the CSNP interval only at the supplied level";
                          }
    
                          leaf csnp-interval-time {
                            type uint32 {
                              range "0..65535";
                            }
                            mandatory true;
                            description
                              "Set CSNP interval";
                          }
                        }  // list level
                      }  // container levels
                    }  // container csnp-interval
    
                    container hello-padding {
                      description
                        "Add padding to IS-IS hello packets";
                      container disable {
                        must "not(../sometimes)";
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable hello-padding";
                      }  // container disable
    
                      container sometimes {
                        must "not(../disable)";
                        presence
                          "Indicates a sometimes node is configured.";
                        description
                          "Enable hello-padding during adjacency formation only";
                      }  // container sometimes
    
                      container levels {
                        description
                          "Set hello-interval for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set hello-interval for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set hello-interval for one level only";
                          }
    
                          container disable {
                            must
                              "not(../sometimes)";
                            presence
                              "Indicates a disable node is configured.";
                            description
                              "Disable hello-padding";
                          }  // container disable
    
                          container sometimes {
                            must
                              "not(../disable)";
                            presence
                              "Indicates a sometimes node is configured.";
                            description
                              "Enable hello-padding during adjacency formation only";
                          }  // container sometimes
                        }  // list level
                      }  // container levels
                    }  // container hello-padding
    
                    container hello-interval {
                      description
                        "Set Hello interval in seconds";
                      leaf hello-interval-time {
                        type uint32 {
                          range "1..65535";
                        }
                        description
                          "Set Hello interval in seconds";
                      }
    
                      container levels {
                        description
                          "Set hello-interval for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set hello-interval for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set hello-interval for one level only";
                          }
    
                          leaf hello-interval-time {
                            type uint32 {
                              range "1..65535";
                            }
                            mandatory true;
                            description
                              "Set Hello interval in seconds";
                          }
                        }  // list level
                      }  // container levels
                    }  // container hello-interval
    
                    container hello-multiplier {
                      description
                        "Set multiplier for Hello holding time";
                      leaf hello-multiplier-value {
                        type uint32 {
                          range "3..1000";
                        }
                        description
                          "Set multiplier for Hello holding time";
                      }
    
                      container levels {
                        description
                          "Set hello-multiplier for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set hello-multiplier for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set hello-multiplier for one level only";
                          }
    
                          leaf hello-multiplier-value {
                            type uint32 {
                              range "3..1000";
                            }
                            mandatory true;
                            description
                              "Set multiplier for Hello holding time";
                          }
                        }  // list level
                      }  // container levels
                    }  // container hello-multiplier
    
                    container lsp-interval {
                      description
                        "Set LSP transmission interval";
                      leaf lsp-interval-time {
                        type uint32 {
                          range "1..4294967295";
                        }
                        description
                          "Set LSP transmission interval";
                      }
    
                      container levels {
                        description
                          "set lsp-interval for this level";
                        list level {
                          key "level-id";
                          description
                            "set lsp-interval for this level";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "set lsp-interval for this level";
                          }
    
                          leaf lsp-interval-time {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            mandatory true;
                            description
                              "Set LSP transmission interval";
                          }
                        }  // list level
                      }  // container levels
                    }  // container lsp-interval
    
                    container hello-password {
                      must
                        "text or hmac-md5 or keychain";
                      presence
                        "Indicates a hello-password node is configured.";
                      description
                        "Configure the IIH password";
                      container text {
                        must
                          "not(../hmac-md5 or ../keychain)";
                        presence
                          "Indicates a text node is configured.";
                        description
                          "Use cleartext password authentication";
                        leaf encrypted {
                          type xr:Proprietary-password;
                          mandatory true;
                          description
                            "The encrypted LSP/SNP password";
                        }
                      }  // container text
    
                      container hmac-md5 {
                        must
                          "not(../text or ../keychain)";
                        presence
                          "Indicates a hmac-md5 node is configured.";
                        description
                          "Use HMAC-MD5 authentication";
                        leaf encrypted {
                          type xr:Proprietary-password;
                          mandatory true;
                          description
                            "The encrypted LSP/SNP password";
                        }
                      }  // container hmac-md5
    
                      container keychain {
                        must
                          "not(../text or ../hmac-md5)";
                        presence
                          "Indicates a keychain node is configured.";
                        description
                          "Specifies a Key Chain name will follow";
                        leaf keychain-name {
                          type string {
                            length "1..1024";
                          }
                          mandatory true;
                          description
                            "Specifies a Key Chain name will follow";
                        }
                      }  // container keychain
    
                      container send-only {
                        presence
                          "Indicates a send-only node is configured.";
                        description
                          "Do not require authentication of incoming IIHs";
                      }  // container send-only
                    }  // container hello-password
    
                    container hello-password-levels {
                      description
                        "Set hello-password for one level only";
                      list level {
                        must
                          "text or hmac-md5 or keychain";
                        key "level-id";
                        description
                          "Set hello-password for one level only";
                        leaf level-id {
                          type uint32 {
                            range "1..2";
                          }
                          description
                            "Set hello-password for one level only";
                        }
    
                        container text {
                          must
                            "not(../hmac-md5 or ../keychain)";
                          presence
                            "Indicates a text node is configured.";
                          description
                            "Use cleartext password authentication";
                          leaf encrypted {
                            type xr:Proprietary-password;
                            mandatory true;
                            description
                              "The encrypted LSP/SNP password";
                          }
                        }  // container text
    
                        container hmac-md5 {
                          must
                            "not(../text or ../keychain)";
                          presence
                            "Indicates a hmac-md5 node is configured.";
                          description
                            "Use HMAC-MD5 authentication";
                          leaf encrypted {
                            type xr:Proprietary-password;
                            mandatory true;
                            description
                              "The encrypted LSP/SNP password";
                          }
                        }  // container hmac-md5
    
                        container keychain {
                          must
                            "not(../text or ../hmac-md5)";
                          presence
                            "Indicates a keychain node is configured.";
                          description
                            "Specifies a Key Chain name will follow";
                          leaf keychain-name {
                            type string {
                              length "1..1024";
                            }
                            mandatory true;
                            description
                              "Specifies a Key Chain name will follow";
                          }
                        }  // container keychain
    
                        container send-only {
                          presence
                            "Indicates a send-only node is configured.";
                          description
                            "Do not require authentication of incoming IIHs";
                        }  // container send-only
                      }  // list level
                    }  // container hello-password-levels
    
                    container hello-password-accept {
                      description
                        "Use password for incoming authentication only";
                      leaf encrypted {
                        type xr:Proprietary-password;
                        description
                          "The encrypted hello password";
                      }
    
                      container levels {
                        description
                          "Set hello-password for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set hello-password for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set hello-password for one level only";
                          }
    
                          leaf encrypted {
                            type xr:Proprietary-password;
                            mandatory true;
                            description
                              "The encrypted hello password";
                          }
                        }  // list level
                      }  // container levels
                    }  // container hello-password-accept
    
                    container lsp {
                      description
                        "LSP configuration";
                      container fast-flood {
                        description
                          "LSP fast flood configuration";
                        container threshold {
                          description
                            "Set LSP transmission fast flood threshold";
                          leaf number-of-lsps {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            description
                              "Set LSP transmission fast flood threshold";
                          }
    
                          container levels {
                            description
                              "Set lsp fast-flood threshold for this level";
                            list level {
                              key "level-id";
                              description
                                "Set lsp fast-flood threshold for this level";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set lsp fast-flood threshold for this level";
                              }
    
                              leaf number-of-lsps {
                                type uint32 {
                                  range
                                    "1..4294967295";
                                }
                                mandatory true;
                                description
                                  "Set LSP transmission fast flood threshold";
                              }
                            }  // list level
                          }  // container levels
                        }  // container threshold
                      }  // container fast-flood
                    }  // container lsp
    
                    container priority {
                      description
                        "Set priority for Designated Router election";
                      leaf priority-value {
                        type uint32 {
                          range "0..127";
                        }
                        description
                          "Set priority for Designated Router election";
                      }
    
                      container levels {
                        description
                          "Set priority for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set priority for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set priority for one level only";
                          }
    
                          leaf priority-value {
                            type uint32 {
                              range "0..127";
                            }
                            mandatory true;
                            description
                              "Set priority for Designated Router election";
                          }
                        }  // list level
                      }  // container levels
                    }  // container priority
    
                    container point-to-point {
                      presence
                        "Indicates a point-to-point node is configured.";
                      description
                        "Treat active LAN interface as point-to-point";
                    }  // container point-to-point
    
                    container retransmit-interval {
                      description
                        "Interval between retransmissions of the same LSP";
                      leaf retransmit-interval-time {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Interval between retransmissions of the same LSP";
                      }
    
                      container levels {
                        description
                          "Set retransmit-interval for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set retransmit-interval for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set retransmit-interval for one level only";
                          }
    
                          leaf retransmit-interval-time {
                            type uint32 {
                              range "0..65535";
                            }
                            mandatory true;
                            description
                              "Interval between retransmissions of the same LSP";
                          }
                        }  // list level
                      }  // container levels
                    }  // container retransmit-interval
    
                    container retransmit-throttle-interval {
                      description
                        "Minimum interval betwen retransissions of different LSPs";
                      leaf retransmit-throttle-interval-time {
                        type uint32 {
                          range "0..65535";
                        }
                        description
                          "Minimum interval betwen retransissions of different LSPs";
                      }
    
                      container levels {
                        description
                          "Set retransmit-throttle-interval for one level only";
                        list level {
                          key "level-id";
                          description
                            "Set retransmit-throttle-interval for one level only";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set retransmit-throttle-interval for one level only";
                          }
    
                          leaf retransmit-throttle-interval-time {
                            type uint32 {
                              range "0..65535";
                            }
                            mandatory true;
                            description
                              "Minimum interval betwen retransissions of different LSPs";
                          }
                        }  // list level
                      }  // container levels
                    }  // container retransmit-throttle-interval
    
                    container link-down {
                      description
                        "Configure interface down event parameters";
                      container fast-detect {
                        presence
                          "Indicates a fast-detect node is configured.";
                        description
                          "Enable high priority detection";
                      }  // container fast-detect
                    }  // container link-down
    
                    container prefix-attributes {
                      description
                        "Set Prefix Attributes";
                      container n-flag-clear {
                        presence
                          "Indicates a n-flag-clear node is configured.";
                        description
                          "Clear N-flag";
                      }  // container n-flag-clear
    
                      container levels {
                        description
                          "Clear N-flag for this level";
                        list level {
                          must "n-flag-clear";
                          key "level-id";
                          description
                            "Clear N-flag for this level";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Clear N-flag for this level";
                          }
    
                          container n-flag-clear {
                            presence
                              "Indicates a n-flag-clear node is configured.";
                            description
                              "Clear N-flag";
                          }  // container n-flag-clear
                        }  // list level
                      }  // container levels
    
                      container anycast {
                        presence
                          "Indicates a anycast node is configured.";
                        description
                          "Prefix has anycast semantics";
                      }  // container anycast
    
                      container anycast-levels {
                        description
                          "Set anycast for this level";
                        list level {
                          key "level-id";
                          description
                            "Set anycast for this level";
                          leaf level-id {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set anycast for this level";
                          }
                        }  // list level
                      }  // container anycast-levels
                    }  // container prefix-attributes
    
                    container affinity {
                      description
                        "Application specific interface affinities";
                      container flex-algos {
                        description
                          "Affinities for Flexible Algorithm application";
                        leaf-list flex-algo {
                          type string {
                            length "1..32";
                          }
                          max-elements 32;
                          description
                            "Affinities for Flexible Algorithm application";
                        }
                      }  // container flex-algos
                    }  // container affinity
    
                    container override {
                      description
                        "Override a configuration setting";
                      container metrics {
                        description
                          "Override the configured link metrics";
                        container maximum {
                          must
                            "not(../high or ../disabled)";
                          presence
                            "Indicates a maximum node is configured.";
                          description
                            "Set metric to unreachable value (wide metrics only)";
                        }  // container maximum
    
                        container high {
                          must
                            "not(../maximum or ../disabled)";
                          presence
                            "Indicates a high node is configured.";
                          description
                            "Set metric to highest reachable value";
                        }  // container high
    
                        container disabled {
                          must
                            "not(../maximum or ../high)";
                          presence
                            "Indicates a disabled node is configured.";
                          description
                            "Ignore reverse-metric requests from neighbors";
                        }  // container disabled
                      }  // container metrics
                    }  // container override
    
                    container delay {
                      description
                        "Delay configuration setting";
                      container normalize {
                        description
                          "Delay normalization setting";
                        leaf interval {
                          type uint32 {
                            range "1..16777215";
                          }
                          description
                            "Normalization interval";
                        }
    
                        leaf offset {
                          type uint32 {
                            range "0..16777215";
                          }
                          must "../interval";
                          description
                            "Normalization offset";
                        }
                      }  // container normalize
                    }  // container delay
    
                    container bfd {
                      description
                        "Configure BFD parameters";
                      container fast-detect {
                        description
                          "Enable Fast detection";
                        container ipv4 {
                          presence
                            "Indicates a ipv4 node is configured.";
                          description
                            "Address Family";
                        }  // container ipv4
    
                        container ipv6 {
                          presence
                            "Indicates a ipv6 node is configured.";
                          description
                            "Address Family";
                        }  // container ipv6
                      }  // container fast-detect
    
                      leaf minimum-interval {
                        type uint32 {
                          range "3..30000";
                        }
                        description
                          "Hello interval";
                      }
    
                      leaf multiplier {
                        type uint32 {
                          range "2..50";
                        }
                        description
                          "Detect multiplier";
                      }
                    }  // container bfd
    
                    container passive {
                      must
                        "not(../suppressed or ../shutdown)";
                      presence
                        "Indicates a passive node is configured.";
                      description
                        "Do not establish adjacencies over this interface";
                    }  // container passive
    
                    container suppressed {
                      must
                        "not(../passive or ../shutdown)";
                      presence
                        "Indicates a suppressed node is configured.";
                      description
                        "Do not advertise connected prefixes of this interface";
                    }  // container suppressed
    
                    container shutdown {
                      must
                        "not(../passive or ../suppressed)";
                      presence
                        "Indicates a shutdown node is configured.";
                      description
                        "Shutdown IS-IS on this interface";
                    }  // container shutdown
    
                    container mesh-group {
                      description
                        "Set IS-IS mesh group";
                      leaf mesh-group-number {
                        type uint32 {
                          range "1..4294967295";
                        }
                        description
                          "Mesh group number";
                      }
    
                      container blocked {
                        presence
                          "Indicates a blocked node is configured.";
                        description
                          "Block LSPs on this interface";
                      }  // container blocked
                    }  // container mesh-group
    
                    container address-families {
                      description
                        "Enter the IS-IS interface address-family configuration submode";
                      list address-family {
                        key "af-name saf-name";
                        description
                          "Address family";
                        leaf af-name {
                          type Isis-af-name;
                          description
                            "Address family name";
                        }
    
                        leaf saf-name {
                          type Isis-saf-name;
                          description
                            "Sub address family name";
                        }
    
                        container metric {
                          description
                            "Configure the metric for interface";
                          leaf default-metric {
                            type uint32 {
                              range
                                "1..16777214";
                            }
                            must
                              "not(../maximum)";
                            description
                              "Default metric";
                          }
    
                          container maximum {
                            must
                              "not(../default-metric)";
                            presence
                              "Indicates a maximum node is configured.";
                            description
                              "Maximum wide metric. All routers will exclude this link from their SPF";
                          }  // container maximum
    
                          container levels {
                            description
                              "Set metric for one level only";
                            list level {
                              key "level-id";
                              description
                                "Set metric for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set metric for one level only";
                              }
    
                              leaf default-metric {
                                type uint32 {
                                  range
                                    "1..16777214";
                                }
                                must
                                  "not(../maximum)";
                                description
                                  "Default metric";
                              }
    
                              container maximum {
                                must
                                  "not(../default-metric)";
                                presence
                                  "Indicates a maximum node is configured.";
                                description
                                  "Maximum wide metric. All routers will exclude this link from their SPF";
                              }  // container maximum
                            }  // list level
                          }  // container levels
    
                          container fallback {
                            description
                              "Configure the metric fallback for interface";
                            container bandwidth {
                              description
                                "fallback based on bandwidth change";
                              leaf multiplier {
                                type uint32 {
                                  range
                                    "2..100000";
                                }
                                must
                                  "../threshold";
                                description
                                  "fallback based on bandwidth change";
                              }
    
                              leaf threshold {
                                type uint32 {
                                  range "1..100";
                                }
                                must
                                  "../multiplier";
                                description
                                  "Threshold interms of percentage of bandwidth";
                              }
                            }  // container bandwidth
    
                            container anomaly {
                              description
                                "Increase the link metric when a delay/loss anomaly occurs";
                              container te-metric {
                                description
                                  "Modify the TE metric";
                                container delay {
                                  must
                                    "not(../loss or ../increment or ../multiplier
                                   or ../maximum) and
                                   (increment or multiplier or maximum)";
                                  presence
                                    "Indicates a delay node is configured.";
                                  description
                                    "Only increase the link metric when a delay anomaly occurs";
                                  leaf increment {
                                    type uint32 {
                                      range
                                        "1..16777213";
                                    }
                                    must
                                      "not(../multiplier or ../maximum)";
                                    description
                                      "Increment the link metric by the following amount";
                                  }
    
                                  leaf multiplier {
                                    type uint32 {
                                      range
                                        "2..100000";
                                    }
                                    must
                                      "not(../increment or ../maximum)";
                                    description
                                      "Multiply the link metric by the following amount";
                                  }
    
                                  container maximum {
                                    must
                                      "not(../increment or ../multiplier)";
                                    presence
                                      "Indicates a maximum node is configured.";
                                    description
                                      "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                  }  // container maximum
                                }  // container delay
    
                                container loss {
                                  must
                                    "not(../delay or ../increment or ../multiplier
                                   or ../maximum) and
                                   (increment or multiplier or maximum)";
                                  presence
                                    "Indicates a loss node is configured.";
                                  description
                                    "Only increase the link metric when a loss anomaly occurs";
                                  leaf increment {
                                    type uint32 {
                                      range
                                        "1..16777213";
                                    }
                                    must
                                      "not(../multiplier or ../maximum)";
                                    description
                                      "Increment the link metric by the following amount";
                                  }
    
                                  leaf multiplier {
                                    type uint32 {
                                      range
                                        "2..100000";
                                    }
                                    must
                                      "not(../increment or ../maximum)";
                                    description
                                      "Multiply the link metric by the following amount";
                                  }
    
                                  container maximum {
                                    must
                                      "not(../increment or ../multiplier)";
                                    presence
                                      "Indicates a maximum node is configured.";
                                    description
                                      "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                  }  // container maximum
                                }  // container loss
    
                                leaf increment {
                                  type uint32 {
                                    range
                                      "1..16777213";
                                  }
                                  must
                                    "not(../delay or ../loss or ../multiplier or
                                   ../maximum)";
                                  description
                                    "Increment the link metric by the following amount";
                                }
    
                                leaf multiplier {
                                  type uint32 {
                                    range
                                      "2..100000";
                                  }
                                  must
                                    "not(../delay or ../loss or ../increment or
                                   ../maximum)";
                                  description
                                    "Multiply the link metric by the following amount";
                                }
    
                                container maximum {
                                  must
                                    "not(../delay or ../loss or ../increment or
                                   ../multiplier)";
                                  presence
                                    "Indicates a maximum node is configured.";
                                  description
                                    "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                }  // container maximum
                              }  // container te-metric
    
                              container te-metric-levels {
                                description
                                  "Increase metric for one level only";
                                list level {
                                  must
                                    "delay or loss or increment or multiplier
                                   or maximum";
                                  key "level-id";
                                  description
                                    "Set metric for one level only";
                                  leaf level-id {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Set metric for one level only";
                                  }
    
                                  container delay {
                                    must
                                      "not(../loss or ../increment or ../multiplier
                                     or ../maximum) and
                                     (increment or multiplier or maximum)";
                                    presence
                                      "Indicates a delay node is configured.";
                                    description
                                      "Only increase the link metric when a delay anomaly occurs";
                                    leaf increment {
                                      type uint32 {
                                        range
                                          "1..16777213";
                                      }
                                      must
                                        "not(../multiplier or ../maximum)";
                                      description
                                        "Increment the link metric by the following amount";
                                    }
    
                                    leaf multiplier {
                                      type uint32 {
                                        range
                                          "2..100000";
                                      }
                                      must
                                        "not(../increment or ../maximum)";
                                      description
                                        "Multiply the link metric by the following amount";
                                    }
    
                                    container maximum {
                                      must
                                        "not(../increment or ../multiplier)";
                                      presence
                                        "Indicates a maximum node is configured.";
                                      description
                                        "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                    }  // container maximum
                                  }  // container delay
    
                                  container loss {
                                    must
                                      "not(../delay or ../increment or
                                     ../multiplier or ../maximum) and
                                     (increment or multiplier or maximum)";
                                    presence
                                      "Indicates a loss node is configured.";
                                    description
                                      "Only increase the link metric when a loss anomaly occurs";
                                    leaf increment {
                                      type uint32 {
                                        range
                                          "1..16777213";
                                      }
                                      must
                                        "not(../multiplier or ../maximum)";
                                      description
                                        "Increment the link metric by the following amount";
                                    }
    
                                    leaf multiplier {
                                      type uint32 {
                                        range
                                          "2..100000";
                                      }
                                      must
                                        "not(../increment or ../maximum)";
                                      description
                                        "Multiply the link metric by the following amount";
                                    }
    
                                    container maximum {
                                      must
                                        "not(../increment or ../multiplier)";
                                      presence
                                        "Indicates a maximum node is configured.";
                                      description
                                        "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                    }  // container maximum
                                  }  // container loss
    
                                  leaf increment {
                                    type uint32 {
                                      range
                                        "1..16777213";
                                    }
                                    must
                                      "not(../delay or ../loss or ../multiplier
                                     or ../maximum)";
                                    description
                                      "Increment the link metric by the following amount";
                                  }
    
                                  leaf multiplier {
                                    type uint32 {
                                      range
                                        "2..100000";
                                    }
                                    must
                                      "not(../delay or ../loss or ../increment
                                     or ../maximum)";
                                    description
                                      "Multiply the link metric by the following amount";
                                  }
    
                                  container maximum {
                                    must
                                      "not(../delay or ../loss or ../increment
                                     or ../multiplier)";
                                    presence
                                      "Indicates a maximum node is configured.";
                                    description
                                      "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                  }  // container maximum
                                }  // list level
                              }  // container te-metric-levels
    
                              container delay {
                                must
                                  "not(../loss or ../increment or ../multiplier
                                 or ../maximum) and
                                 (increment or multiplier or maximum)";
                                presence
                                  "Indicates a delay node is configured.";
                                description
                                  "Only increase the link metric when a delay anomaly occurs";
                                leaf increment {
                                  type uint32 {
                                    range
                                      "1..16777213";
                                  }
                                  must
                                    "not(../multiplier or ../maximum)";
                                  description
                                    "Increment the link metric by the following amount";
                                }
    
                                leaf multiplier {
                                  type uint32 {
                                    range
                                      "2..100000";
                                  }
                                  must
                                    "not(../increment or ../maximum)";
                                  description
                                    "Multiply the link metric by the following amount";
                                }
    
                                container maximum {
                                  must
                                    "not(../increment or ../multiplier)";
                                  presence
                                    "Indicates a maximum node is configured.";
                                  description
                                    "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                }  // container maximum
                              }  // container delay
    
                              container loss {
                                must
                                  "not(../loss or ../increment or ../multiplier
                                 or ../maximum) and
                                 (increment or multiplier or maximum)";
                                presence
                                  "Indicates a loss node is configured.";
                                description
                                  "Only increase the link metric when a loss anomaly occurs";
                                leaf increment {
                                  type uint32 {
                                    range
                                      "1..16777213";
                                  }
                                  must
                                    "not(../multiplier or ../maximum)";
                                  description
                                    "Increment the link metric by the following amount";
                                }
    
                                leaf multiplier {
                                  type uint32 {
                                    range
                                      "2..100000";
                                  }
                                  must
                                    "not(../increment or ../maximum)";
                                  description
                                    "Multiply the link metric by the following amount";
                                }
    
                                container maximum {
                                  must
                                    "not(../increment or ../multiplier)";
                                  presence
                                    "Indicates a maximum node is configured.";
                                  description
                                    "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                }  // container maximum
                              }  // container loss
    
                              leaf increment {
                                type uint32 {
                                  range
                                    "1..16777213";
                                }
                                must
                                  "not(../delay or ../loss or ../multiplier
                                 or ../maximum)";
                                description
                                  "Increment the link metric by the following amount";
                              }
    
                              leaf multiplier {
                                type uint32 {
                                  range
                                    "2..100000";
                                }
                                must
                                  "not(../delay or ../loss or ../increment
                                 or ../maximum)";
                                description
                                  "Multiply the link metric by the following amount";
                              }
    
                              container maximum {
                                must
                                  "not(../delay or ../loss or ../increment
                                 or ../multiplier)";
                                presence
                                  "Indicates a maximum node is configured.";
                                description
                                  "Set the maximum wide metric. All routers will exclude this link from their SPF";
                              }  // container maximum
    
                              container levels {
                                description
                                  "Increase metric for one level only";
                                list level {
                                  must
                                    "delay or loss or increment or multiplier
                                   or maximum";
                                  key "level-id";
                                  description
                                    "Set metric for one level only";
                                  leaf level-id {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Set metric for one level only";
                                  }
    
                                  container delay {
                                    must
                                      "not(../loss or ../increment or
                                     ../multiplier or ../maximum) and
                                     (increment or multiplier or maximum)";
                                    presence
                                      "Indicates a delay node is configured.";
                                    description
                                      "Only increase the link metric when a delay anomaly occurs";
                                    leaf increment {
                                      type uint32 {
                                        range
                                          "1..16777213";
                                      }
                                      must
                                        "not(../multiplier or ../maximum)";
                                      description
                                        "Increment the link metric by the following amount";
                                    }
    
                                    leaf multiplier {
                                      type uint32 {
                                        range
                                          "2..100000";
                                      }
                                      must
                                        "not(../increment or ../maximum)";
                                      description
                                        "Multiply the link metric by the following amount";
                                    }
    
                                    container maximum {
                                      must
                                        "not(../increment or ../multiplier)";
                                      presence
                                        "Indicates a maximum node is configured.";
                                      description
                                        "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                    }  // container maximum
                                  }  // container delay
    
                                  container loss {
                                    must
                                      "not(../delay or ../increment or
                                     ../multiplier or ../maximum) and
                                     (increment or multiplier or maximum)";
                                    presence
                                      "Indicates a loss node is configured.";
                                    description
                                      "Only increase the link metric when a loss anomaly occurs";
                                    leaf increment {
                                      type uint32 {
                                        range
                                          "1..16777213";
                                      }
                                      must
                                        "not(../multiplier or ../maximum)";
                                      description
                                        "Increment the link metric by the following amount";
                                    }
    
                                    leaf multiplier {
                                      type uint32 {
                                        range
                                          "2..100000";
                                      }
                                      must
                                        "not(../increment or ../maximum)";
                                      description
                                        "Multiply the link metric by the following amount";
                                    }
    
                                    container maximum {
                                      must
                                        "not(../increment or ../multiplier)";
                                      presence
                                        "Indicates a maximum node is configured.";
                                      description
                                        "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                    }  // container maximum
                                  }  // container loss
    
                                  leaf increment {
                                    type uint32 {
                                      range
                                        "1..16777213";
                                    }
                                    must
                                      "not(../delay or ../loss or ../multiplier
                                     or ../maximum)";
                                    description
                                      "Increment the link metric by the following amount";
                                  }
    
                                  leaf multiplier {
                                    type uint32 {
                                      range
                                        "2..100000";
                                    }
                                    must
                                      "not(../delay or ../loss or ../increment
                                     or ../maximum)";
                                    description
                                      "Multiply the link metric by the following amount";
                                  }
    
                                  container maximum {
                                    must
                                      "not(../delay or ../loss or ../increment
                                     or ../multiplier)";
                                    presence
                                      "Indicates a maximum node is configured.";
                                    description
                                      "Set the maximum wide metric. All routers will exclude this link from their SPF";
                                  }  // container maximum
                                }  // list level
                              }  // container levels
                            }  // container anomaly
                          }  // container fallback
                        }  // container metric
    
                        container te-metric {
                          description
                            "Configure an application specific TE metric for the interface";
                          leaf flex-algo {
                            type uint32 {
                              range
                                "1..16777214";
                            }
                            description
                              "Configure a Flex-algo TE metric for the interface";
                          }
                        }  // container te-metric
    
                        container te-metric-levels {
                          description
                            "Set metric for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set metric for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set metric for one level only";
                            }
    
                            leaf flex-algo {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              mandatory true;
                              description
                                "Configure a Flex-algo TE metric for the interface";
                            }
                          }  // list level
                        }  // container te-metric-levels
    
                        container mpls {
                          when
                            "../saf-name = 'unicast'";
                          description
                            "Configure MPLS routing protocol parameters";
                          container ldp {
                            description
                              "Configure LDP parameters";
                            container sync {
                              presence
                                "Indicates a sync node is configured.";
                              description
                                "Configure LDP ISIS synchronization";
                              leaf level {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set LDP synchronization for one level only";
                              }
                            }  // container sync
                          }  // container ldp
                        }  // container mpls
    
                        container tag {
                          description
                            "Set interface tag";
                          leaf interface-tag {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            description
                              "Set interface tag";
                          }
    
                          container levels {
                            description
                              "Set the tag only at supplied level";
                            list level {
                              key "level-id";
                              description
                                "Set the tag only at supplied level";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set the tag only at supplied level";
                              }
    
                              leaf interface-tag {
                                type uint32 {
                                  range
                                    "1..4294967295";
                                }
                                mandatory true;
                                description
                                  "Set interface tag";
                              }
                            }  // list level
                          }  // container levels
                        }  // container tag
    
                        container prefix-sid {
                          tailf:dependency "../../../interface-name";
                          when
                            "../saf-name = 'unicast' and ../../../interface-name[starts-with(text(),'Loopback')]";
                          container sid {
                            must
                              "index or absolute";
                            presence
                              "Indicates a sid node is configured.";
                            description
                              "Specify the Prefix Segment ID";
                            container index {
                              must
                                "not(../absolute)";
                              presence
                                "Indicates a index node is configured.";
                              description
                                "Specify the index of Prefix Segement ID";
                              leaf sid-index {
                                type uint32 {
                                  range
                                    "0..1048575";
                                }
                                mandatory true;
                                description
                                  "Specify the index of Prefix Segement ID";
                              }
                            }  // container index
    
                            container absolute {
                              must
                                "not(../index)";
                              presence
                                "Indicates a absolute node is configured.";
                              description
                                "Specify the absolute value of Prefix Segement ID";
                              leaf sid-value {
                                type uint32 {
                                  range
                                    "16000..1048575";
                                }
                                mandatory true;
                                description
                                  "Specify the absolute value of Prefix Segement ID";
                              }
                            }  // container absolute
    
                            container explicit-null {
                              presence
                                "Indicates a explicit-null node is configured.";
                              description
                                "Upstream neighbor must replace prefix-sid with explicit null label";
                            }  // container explicit-null
    
                            container n-flag-clear {
                              presence
                                "Indicates a n-flag-clear node is configured.";
                              description
                                "Clear N-flag for the prefix-SID ";
                            }  // container n-flag-clear
                          }  // container sid
    
                          container strict-spf {
                            must
                              "index or absolute";
                            presence
                              "Indicates a strict-spf node is configured.";
                            description
                              "Strict-SPF Prefix SID Configuration";
                            container index {
                              must
                                "not(../absolute)";
                              presence
                                "Indicates a index node is configured.";
                              description
                                "Specify the index of Prefix Segement ID";
                              leaf sid-index {
                                type uint32 {
                                  range
                                    "0..1048575";
                                }
                                mandatory true;
                                description
                                  "Specify the index of Prefix Segement ID";
                              }
                            }  // container index
    
                            container absolute {
                              must
                                "not(../index)";
                              presence
                                "Indicates a absolute node is configured.";
                              description
                                "Specify the absolute value of Prefix Segement ID";
                              leaf sid-value {
                                type uint32 {
                                  range
                                    "16000..1048575";
                                }
                                mandatory true;
                                description
                                  "Specify the absolute value of Prefix Segement ID";
                              }
                            }  // container absolute
    
                            container explicit-null {
                              presence
                                "Indicates a explicit-null node is configured.";
                              description
                                "Upstream neighbor must replace prefix-sid with explicit null label";
                            }  // container explicit-null
    
                            container n-flag-clear {
                              presence
                                "Indicates a n-flag-clear node is configured.";
                              description
                                "Clear N-flag for the prefix-SID ";
                            }  // container n-flag-clear
                          }  // container strict-spf
    
                          container algorithms {
                            description
                              "Algorithm Specific Prefix SID Configuration";
                            list algorithm {
                              key "algorithm-number";
                              description
                                "Algorithm Specific Prefix SID Configuration";
                              leaf algorithm-number {
                                type uint32 {
                                  range
                                    "128..255";
                                }
                                description
                                  "Algorithm Specific Prefix SID Configuration";
                              }
    
                              container index {
                                must
                                  "not(../absolute)";
                                presence
                                  "Indicates a index node is configured.";
                                description
                                  "Specify the index of Prefix Segement ID";
                                leaf sid-index {
                                  type uint32 {
                                    range
                                      "0..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the index of Prefix Segement ID";
                                }
                              }  // container index
    
                              container absolute {
                                must
                                  "not(../index)";
                                presence
                                  "Indicates a absolute node is configured.";
                                description
                                  "Specify the absolute value of Prefix Segement ID";
                                leaf sid-value {
                                  type uint32 {
                                    range
                                      "16000..1048575";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Specify the absolute value of Prefix Segement ID";
                                }
                              }  // container absolute
    
                              container explicit-null {
                                presence
                                  "Indicates a explicit-null node is configured.";
                                description
                                  "Upstream neighbor must replace prefix-sid with explicit null label";
                              }  // container explicit-null
    
                              container n-flag-clear {
                                presence
                                  "Indicates a n-flag-clear node is configured.";
                                description
                                  "Clear N-flag for the prefix-SID ";
                              }  // container n-flag-clear
                            }  // list algorithm
                          }  // container algorithms
                        }  // container prefix-sid
    
                        container adjacency-sid {
                          when
                            "../saf-name = 'unicast'";
                          description
                            "Specify the Adjacency Segment ID";
                          container indexes {
                            description
                              "Specify the index of Adjacency Segement ID";
                            list index {
                              key "sid-index";
                              description
                                "Specify the index of Adjacency Segement ID";
                              leaf sid-index {
                                type uint32 {
                                  range
                                    "0..1048575";
                                }
                                description
                                  "Specify the index of Adjacency Segement ID";
                              }
    
                              container protected {
                                presence
                                  "Indicates a protected node is configured.";
                                description
                                  "Protect Adjacency SID";
                              }  // container protected
                            }  // list index
                          }  // container indexes
    
                          container absolutes {
                            description
                              "Specify the absolute value of Adjacency Segement ID";
                            list absolute {
                              key "sid-value";
                              description
                                "Specify the absolute value of Adjacency Segement ID";
                              leaf sid-value {
                                type uint32 {
                                  range
                                    "0..1048575";
                                }
                                description
                                  "Specify the absolute value of Adjacency Segement ID";
                              }
    
                              container protected {
                                presence
                                  "Indicates a protected node is configured.";
                                description
                                  "Protect Adjacency SID";
                              }  // container protected
                            }  // list absolute
                          }  // container absolutes
                        }  // container adjacency-sid
    
                        container fast-reroute {
                          when
                            "../saf-name = 'unicast'";
                          description
                            "Configure Fast ReRoute";
                          container computation {
                            container per-link-computation {
                              must
                                "not(../per-prefix-computation)";
                              presence
                                "Indicates a per-link-computation node is configured.";
                              description
                                "Prefix independent per-link computation";
                            }  // container per-link-computation
    
                            container per-prefix-computation {
                              must
                                "not(../per-link-computation)";
                              presence
                                "Indicates a per-prefix-computation node is configured.";
                              description
                                "Prefix dependent computation";
                            }  // container per-prefix-computation
    
                            container levels {
                              description
                                "Configure FRR for one level only";
                              list level {
                                must
                                  "per-link-computation or per-prefix-computation";
                                key "level-id";
                                description
                                  "Configure FRR for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Configure FRR for one level only";
                                }
    
                                container per-link-computation {
                                  must
                                    "not(../per-prefix-computation)";
                                  presence
                                    "Indicates a per-link node is configured.";
                                  description
                                    "Prefix independent per-link computation";
                                }  // container per-link-computation
    
                                container per-prefix-computation {
                                  must
                                    "not(../per-link-computation)";
                                  presence
                                    "Indicates a per-prefix node is configured.";
                                  description
                                    "Prefix dependent computation";
                                }  // container per-prefix-computation
                              }  // list level
                            }  // container levels
                          }  // container computation
    
                          container per-link {
                            description
                              "Prefix independent per-link computation";
                            container exclude {
                              description
                                "FRR exclusion information";
                              container interfaces {
                                description
                                  "Exclude an interface from computation";
                                list interface {
                                  key "interface-name";
                                  description
                                    "Exclude an interface from computation";
                                  leaf interface-name {
                                    type xr:Interface-name;
                                    description
                                      "Exclude an interface from computation";
                                  }
    
                                  leaf level {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Exclude interface for one level only";
                                  }
                                }  // list interface
                              }  // container interfaces
                            }  // container exclude
    
                            container lfa-candidate {
                              description
                                "FRR LFA candidate information";
                              container interfaces {
                                description
                                  "Include an interface to LFA candidate in computation";
                                list interface {
                                  key "interface-name";
                                  description
                                    "Include an interface to LFA candidate in computation";
                                  leaf interface-name {
                                    type xr:Interface-name;
                                    description
                                      "Include an interface to LFA candidate in computation";
                                  }
    
                                  leaf level {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Include interface for one level only";
                                  }
                                }  // list interface
                              }  // container interfaces
                            }  // container lfa-candidate
                          }  // container per-link
    
                          container per-prefix {
                            description
                              "Prefix dependent computation";
                            container remote-lfa {
                              description
                                "Enable remote LFA computation";
                              container tunnel {
                                description
                                  "Enable remote LFA computation using tunnels";
                                container mpls-ldp {
                                  presence
                                    "Indicates a mpls-ldp node is configured.";
                                  description
                                    "Use MPLS LDP tunnel to reach the remote LFA node";
                                }  // container mpls-ldp
    
                                container levels {
                                  description
                                    "Enable remote LFA for one level only";
                                  list level {
                                    must
                                      "mpls-ldp";
                                    key "level-id";
                                    description
                                      "Enable remote LFA for one level only";
                                    leaf level-id {
                                      type uint32 {
                                        range
                                          "1..2";
                                      }
                                      description
                                        "Enable remote LFA for one level only";
                                    }
    
                                    container mpls-ldp {
                                      presence
                                        "Indicates a mpls-ldp node is configured.";
                                      description
                                        "Use MPLS LDP tunnel to reach the remote LFA node";
                                    }  // container mpls-ldp
                                  }  // list level
                                }  // container levels
                              }  // container tunnel
    
                              container maximum-metric {
                                description
                                  "Limit remote LFA node selection within the metric";
                                leaf metric {
                                  type uint32 {
                                    range
                                      "1..16777215";
                                  }
                                  description
                                    "Value of the metric";
                                }
    
                                container levels {
                                  description
                                    "Enable remote LFA max metric for one level only";
                                  list level {
                                    key "level-id";
                                    description
                                      "Enable remote LFA max metric for one level only";
                                    leaf level-id {
                                      type uint32 {
                                        range
                                          "1..2";
                                      }
                                      description
                                        "Enable remote LFA max metric for one level only";
                                    }
    
                                    leaf metric {
                                      type uint32 {
                                        range
                                          "1..16777215";
                                      }
                                      mandatory
                                        true;
                                      description
                                        "Value of the metric";
                                    }
                                  }  // list level
                                }  // container levels
                              }  // container maximum-metric
                            }  // container remote-lfa
    
                            container per-prefix {
                              description
                                "Prefix dependent computation";
                              container ti-lfa {
                                presence
                                  "Indicates a ti-lfa node is configured.";
                                description
                                  "Enable TI LFA computation";
                              }  // container ti-lfa
    
                              container levels {
                                description
                                  "Enable EPCFRR LFA for one level only";
                                list level {
                                  must "ti-lfa";
                                  key "level-id";
                                  description
                                    "Enable EPCFRR LFA for one level only";
                                  leaf level-id {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Enable EPCFRR LFA for one level only";
                                  }
    
                                  container ti-lfa {
                                    presence
                                      "Indicates a ti-lfa node is configured.";
                                    description
                                      "Enable TI LFA computation";
                                  }  // container ti-lfa
                                }  // list level
                              }  // container levels
                            }  // container per-prefix
    
                            container tiebreaker {
                              description
                                "Configure tiebreaker for multiple backups";
                              container node-protecting {
                                description
                                  "Prefer node protecting backup path";
                                container index {
                                  description
                                    "Set preference order among tiebreakers";
                                  leaf preference-order {
                                    type uint32 {
                                      range
                                        "1..255";
                                    }
                                    description
                                      "Set preference order among tiebreakers";
                                  }
    
                                  container levels {
                                    description
                                      "Configure tiebreaker for one level only";
                                    list level {
                                      key "level-id";
                                      description
                                        "Configure tiebreaker for one level only";
                                      leaf level-id {
                                        type uint32 {
                                          range
                                            "1..2";
                                        }
                                        description
                                          "Configure tiebreaker for one level only";
                                      }
    
                                      leaf preference-order {
                                        type uint32 {
                                          range
                                            "1..255";
                                        }
                                        mandatory
                                          true;
                                        description
                                          "Set preference order among tiebreakers";
                                      }
                                    }  // list level
                                  }  // container levels
                                }  // container index
                              }  // container node-protecting
    
                              container srlg-disjoint {
                                description
                                  "Prefer SRLG disjoint backup path";
                                container index {
                                  description
                                    "Set preference order among tiebreakers";
                                  leaf preference-order {
                                    type uint32 {
                                      range
                                        "1..255";
                                    }
                                    description
                                      "Set preference order among tiebreakers";
                                  }
    
                                  container levels {
                                    description
                                      "Configure tiebreaker for one level only";
                                    list level {
                                      key "level-id";
                                      description
                                        "Configure tiebreaker for one level only";
                                      leaf level-id {
                                        type uint32 {
                                          range
                                            "1..2";
                                        }
                                        description
                                          "Configure tiebreaker for one level only";
                                      }
    
                                      leaf preference-order {
                                        type uint32 {
                                          range
                                            "1..255";
                                        }
                                        mandatory
                                          true;
                                        description
                                          "Set preference order among tiebreakers";
                                      }
                                    }  // list level
                                  }  // container levels
                                }  // container index
                              }  // container srlg-disjoint
    
                              container default {
                                description
                                  "Prefer default (link protecting) backup path";
                                container default-backup-path {
                                  presence
                                    "Indicates a default node is configured.";
                                  description
                                    "Prefer default (link protecting) backup path";
                                }  // container default-backup-path
    
                                container levels {
                                  description
                                    "Configure tiebreaker for one level only";
                                  list level {
                                    must
                                      "default-backup-path";
                                    key "level-id";
                                    description
                                      "Configure tiebreaker for one level only";
                                    leaf level-id {
                                      type uint32 {
                                        range
                                          "1..2";
                                      }
                                      description
                                        "Configure tiebreaker for one level only";
                                    }
    
                                    container default-backup-path {
                                      presence
                                        "Indicates a default node is configured.";
                                      description
                                        "Prefer default (link protecting) backup path";
                                    }  // container default-backup-path
                                  }  // list level
                                }  // container levels
                              }  // container default
                            }  // container tiebreaker
    
                            container exclude {
                              description
                                "FRR exclusion information";
                              container interfaces {
                                description
                                  "Exclude an interface from computation";
                                list interface {
                                  key "interface-name";
                                  description
                                    "Exclude an interface from computation";
                                  leaf interface-name {
                                    type xr:Interface-name;
                                    description
                                      "Exclude an interface from computation";
                                  }
    
                                  leaf level {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Exclude interface for one level only";
                                  }
                                }  // list interface
                              }  // container interfaces
                            }  // container exclude
    
                            container lfa-candidate {
                              description
                                "FRR LFA candidate information";
                              container interfaces {
                                description
                                  "Include an interface to LFA candidate in computation";
                                list interface {
                                  key "interface-name";
                                  description
                                    "Include an interface to LFA candidate in computation";
                                  leaf interface-name {
                                    type xr:Interface-name;
                                    description
                                      "Include an interface to LFA candidate in computation";
                                  }
    
                                  leaf level {
                                    type uint32 {
                                      range
                                        "1..2";
                                    }
                                    description
                                      "Include interface for one level only";
                                  }
                                }  // list interface
                              }  // container interfaces
                            }  // container lfa-candidate
                          }  // container per-prefix
                        }  // container fast-reroute
    
                        container link-group {
                          presence
                            "Indicates a link-group node is configured.";
                          description
                            "Set interface link group";
                          leaf link-group-name {
                            type string {
                              length "1..40";
                            }
                            mandatory true;
                            description
                              "Set interface link group";
                          }
    
                          leaf level {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set the tag only at supplied level";
                          }
                        }  // container link-group
    
                        container weight {
                          description
                            "Configure weight for the interface";
                          leaf weight-value {
                            type uint32 {
                              range
                                "1..16777214";
                            }
                            description
                              "Configure weight for the interface";
                          }
    
                          container levels {
                            description
                              "Set weight for one level only";
                            list level {
                              key "level-id";
                              description
                                "Set weight for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set weight for one level only";
                              }
    
                              leaf weight-value {
                                type uint32 {
                                  range
                                    "1..16777214";
                                }
                                mandatory true;
                                description
                                  "Configure weight for the interface";
                              }
                            }  // list level
                          }  // container levels
                        }  // container weight
    
                        container auto-metric {
                          description
                            "Configure the auto-metric for interface";
                          container proactive-protect {
                            description
                              "set auto-metric proactive-protect mode";
                            leaf absolute-metric {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              description
                                "Absolute metric: <1-63> for narrow, <1-16777214> for wide";
                            }
    
                            container levels {
                              description
                                "Set metric for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Set metric for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Set metric for one level only";
                                }
    
                                leaf absolute-metric {
                                  type uint32 {
                                    range
                                      "1..16777214";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Absolute metric: <1-63> for narrow, <1-16777214> for wide";
                                }
                              }  // list level
                            }  // container levels
                          }  // container proactive-protect
                        }  // container auto-metric
    
                        container advertise {
                          when
                            "../saf-name = 'unicast'";
                          description
                            "Configure the AF specific advertisement";
                          container prefix {
                            description
                              "Configure the prefix advertisement";
                            leaf route-policy {
                              type xr:Route-policy-name;
                              description
                                "Filter routes based on a route policy";
                            }
    
                            container levels {
                              description
                                "Set advertisement for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Set advertisement for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Set advertisement for one level only";
                                }
    
                                leaf route-policy {
                                  type xr:Route-policy-name;
                                  description
                                    "Filter routes based on a route policy";
                                }
                              }  // list level
                            }  // container levels
                          }  // container prefix
                        }  // container advertise
    
                        container disable {
                          presence
                            "Indicates a disable node is configured.";
                          description
                            "Disable IS-IS for this topology on this interface";
                        }  // container disable
                      }  // list address-family
    
                      list address-family-topology {
                        key "af-name saf-name topology-name";
                        description
                          "Address family with a non-default topology";
                        leaf af-name {
                          type Isis-af-name;
                          description
                            "Address family name";
                        }
    
                        leaf saf-name {
                          type Isis-saf-name;
                          description
                            "Sub address family name";
                        }
    
                        leaf topology-name {
                          type string {
                            length "1..32";
                          }
                          description
                            "Specify a non-default topology";
                        }
    
                        container metric {
                          description
                            "Configure the metric for interface";
                          leaf default-metric {
                            type uint32 {
                              range
                                "1..16777214";
                            }
                            must
                              "not(../maximum)";
                            description
                              "Default metric";
                          }
    
                          container maximum {
                            must
                              "not(../default-metric)";
                            presence
                              "Indicates a maximum node is configured.";
                            description
                              "Maximum wide metric. All routers will exclude this link from their SPF";
                          }  // container maximum
    
                          container levels {
                            description
                              "Set metric for one level only";
                            list level {
                              key "level-id";
                              description
                                "Set metric for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set metric for one level only";
                              }
    
                              leaf default-metric {
                                type uint32 {
                                  range
                                    "1..16777214";
                                }
                                must
                                  "not(../maximum)";
                                description
                                  "Default metric";
                              }
    
                              container maximum {
                                must
                                  "not(../default-metric)";
                                presence
                                  "Indicates a maximum node is configured.";
                                description
                                  "Maximum wide metric. All routers will exclude this link from their SPF";
                              }  // container maximum
                            }  // list level
                          }  // container levels
    
                          container fallback {
                            description
                              "Configure the metric fallback for interface";
                            container bandwidth {
                              description
                                "fallback based on bandwidth change";
                              leaf multiplier {
                                type uint32 {
                                  range
                                    "2..100000";
                                }
                                must
                                  "../threshold";
                                description
                                  "fallback based on bandwidth change";
                              }
    
                              leaf threshold {
                                type uint32 {
                                  range "1..100";
                                }
                                must
                                  "../multiplier";
                                description
                                  "Threshold interms of percentage of bandwidth";
                              }
                            }  // container bandwidth
                          }  // container fallback
                        }  // container metric
    
                        container te-metric {
                          description
                            "Configure an application specific TE metric for the interface";
                          leaf flex-algo {
                            type uint32 {
                              range
                                "1..16777214";
                            }
                            description
                              "Configure a Flex-algo TE metric for the interface";
                          }
                        }  // container te-metric
    
                        container te-metric-levels {
                          description
                            "Set metric for one level only";
                          list level {
                            key "level-id";
                            description
                              "Set metric for one level only";
                            leaf level-id {
                              type uint32 {
                                range "1..2";
                              }
                              description
                                "Set metric for one level only";
                            }
    
                            leaf flex-algo {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              mandatory true;
                              description
                                "Configure a Flex-algo TE metric for the interface";
                            }
                          }  // list level
                        }  // container te-metric-levels
    
                        container tag {
                          description
                            "Set interface tag";
                          leaf interface-tag {
                            type uint32 {
                              range
                                "1..4294967295";
                            }
                            description
                              "Set interface tag";
                          }
    
                          container levels {
                            description
                              "Set the tag only at supplied level";
                            list level {
                              key "level-id";
                              description
                                "Set the tag only at supplied level";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set the tag only at supplied level";
                              }
    
                              leaf interface-tag {
                                type uint32 {
                                  range
                                    "1..4294967295";
                                }
                                mandatory true;
                                description
                                  "Set interface tag";
                              }
                            }  // list level
                          }  // container levels
                        }  // container tag
    
                        container link-group {
                          presence
                            "Indicates a link-group node is configured.";
                          description
                            "Set interface link group";
                          leaf link-group-name {
                            type string {
                              length "1..40";
                            }
                            mandatory true;
                            description
                              "Set interface link group";
                          }
    
                          leaf level {
                            type uint32 {
                              range "1..2";
                            }
                            description
                              "Set the tag only at supplied level";
                          }
                        }  // container link-group
    
                        container weight {
                          description
                            "Configure weight for the interface";
                          leaf weight-value {
                            type uint32 {
                              range
                                "1..16777214";
                            }
                            description
                              "Configure weight for the interface";
                          }
    
                          container levels {
                            description
                              "Set weight for one level only";
                            list level {
                              key "level-id";
                              description
                                "Set weight for one level only";
                              leaf level-id {
                                type uint32 {
                                  range "1..2";
                                }
                                description
                                  "Set weight for one level only";
                              }
    
                              leaf weight-value {
                                type uint32 {
                                  range
                                    "1..16777214";
                                }
                                mandatory true;
                                description
                                  "Configure weight for the interface";
                              }
                            }  // list level
                          }  // container levels
                        }  // container weight
    
                        container auto-metric {
                          description
                            "Configure the auto-metric for interface";
                          container proactive-protect {
                            description
                              "set auto-metric proactive-protect mode";
                            leaf absolute-metric {
                              type uint32 {
                                range
                                  "1..16777214";
                              }
                              description
                                "Absolute metric: <1-63> for narrow, <1-16777214> for wide";
                            }
    
                            container levels {
                              description
                                "Set metric for one level only";
                              list level {
                                key "level-id";
                                description
                                  "Set metric for one level only";
                                leaf level-id {
                                  type uint32 {
                                    range "1..2";
                                  }
                                  description
                                    "Set metric for one level only";
                                }
    
                                leaf absolute-metric {
                                  type uint32 {
                                    range
                                      "1..16777214";
                                  }
                                  mandatory
                                    true;
                                  description
                                    "Absolute metric: <1-63> for narrow, <1-16777214> for wide";
                                }
                              }  // list level
                            }  // container levels
                          }  // container proactive-protect
                        }  // container auto-metric
    
                        container disable {
                          presence
                            "Indicates a disable node is configured.";
                          description
                            "Disable IS-IS for this topology on this interface";
                        }  // container disable
                      }  // list address-family-topology
                    }  // container address-families
                  }  // list interface
                }  // container interfaces
    
                container distribute {
                  description
                    "Distribute routing information to external services";
                  container link-state {
                    presence
                      "Indicates a link-state node is configured";
                    description
                      "Distribute the link-state database to external services";
                    leaf instance-id {
                      type uint32 {
                        range "32..4294967295";
                      }
                      description
                        "Set distribution process instance identifier";
                    }
    
                    leaf throttle {
                      type uint32 {
                        range "1..20";
                      }
                      description
                        "Set throttle update in seconds";
                    }
    
                    leaf level {
                      type uint32 {
                        range "1..2";
                      }
                      description
                        "Set distribution for one level only";
                    }
                  }  // container link-state
                }  // container distribute
    
                container segment-routing {
                  description
                    "IS-IS segment-routing configuration";
                  container global-block {
                    presence
                      "Indicates a global-block node is configured.";
                    description
                      "Prefix-SID Global label Block (SRGB)";
                    leaf lower-bound {
                      type uint32 {
                        range "16000..1048575";
                      }
                      mandatory true;
                      description
                        "Prefix-SID Global label Block (SRGB)";
                    }
    
                    leaf upper-bound {
                      type uint32 {
                        range "1..1048575";
                      }
                      mandatory true;
                      description
                        "The upper bound SRGB";
                    }
                  }  // container global-block
                }  // container segment-routing
    
                container adjacency {
                  description
                    "ISIS adjacency bring up";
                  container stagger {
                    presence
                      "Indicates a stagger node is configured.";
                    description
                      "Stagger ISIS adjacency bring up";
                    leaf initial-number-of-neighbors {
                      type uint32 {
                        range "2..65000";
                      }
                      must
                        "../maximum-simultaneous-neighbors";
                      description
                        "Initial number of neighbors to bring up (default 2)";
                    }
    
                    leaf maximum-simultaneous-neighbors {
                      type uint32 {
                        range "2..65000";
                      }
                      must
                        "../initial-number-of-neighbors";
                      description
                        "Maximum simultaneous neighbors to bring up (default 64)";
                    }
                  }  // container stagger
                }  // container adjacency
    
                container flex-algos {
                  description
                    "Flex Algorithm definition";
                  list flex-algo {
                    key "algorithm-number";
                    description
                      "Flex Algorithm definition";
                    leaf algorithm-number {
                      type uint32 {
                        range "128..255";
                      }
                      description
                        "Flex Algorithm definition";
                    }
    
                    container affinity {
                      description
                        "Specify affinity names to exclude";
                      container exclude-anies {
                        description
                          "Exclude objects in flex-algo calculation";
                        leaf-list exclude-any {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          max-elements 32;
                          description
                            "Exclude objects in flex-algo calculation";
                        }
                      }  // container exclude-anies
    
                      container include-anies {
                        description
                          "Include objects in flex-algo calculation";
                        leaf-list include-any {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          max-elements 32;
                          description
                            "Include objects in flex-algo calculation";
                        }
                      }  // container include-anies
    
                      container include-alls {
                        description
                          "Include objects in flex-algo calculation";
                        leaf-list include-all {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          max-elements 32;
                          description
                            "Include objects in flex-algo calculation";
                        }
                      }  // container include-alls
                    }  // container affinity
    
                    container srlg {
                      description
                        "Specify SRLG names";
                      container exclude-anies {
                        description
                          "Exclude objects in flex-algo calculation";
                        leaf-list exclude-any {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          max-elements 32;
                          description
                            "Exclude objects in flex-algo calculation";
                        }
                      }  // container exclude-anies
                    }  // container srlg
    
                    leaf priority {
                      type uint32 {
                        range "0..255";
                      }
                      description
                        "Flex-Algo definition priority";
                    }
    
                    container metric-type {
                      description
                        "Metric-type used by flex-algo calculation";
                      container delay {
                        must "not(../te)";
                        presence
                          "Indicates a delay node is configured.";
                        description
                          "Use delay as metric";
                      }  // container delay
    
                      container te {
                        must "not(../delay)";
                        presence
                          "Indicates a te node is configured.";
                        description
                          "Use Traffic Engineering metric";
                      }  // container te
                    }  // container metric-type
    
                    container fast-reroute {
                      description
                        "Configure Fast ReRoute";
                      container disable {
                        presence
                          "Indicates a disable node is configured.";
                        description
                          "Disable Fast ReRoute for Flex-Algo";
                      }  // container disable
                    }  // container fast-reroute
    
                    container microloop {
                      description
                        "Configure Microloop";
                      container avoidance {
                        description
                          "Configure Microloop Avoidance";
                        container disable {
                          presence
                            "Indicates a disable node is configured.";
                          description
                            "Disable Microloop Avoidance for Flex-Algo";
                        }  // container disable
                      }  // container avoidance
                    }  // container microloop
    
                    container advertise-definition {
                      presence
                        "Indicates a advertise-definition node is configured.";
                      description
                        "Advertise the Flex-Algo Definition";
                    }  // container advertise-definition
    
                    container prefix-metric {
                      presence
                        "Indicates a prefix-metric node is configured.";
                      description
                        "Use Flex-Algo Prefix Metric";
                    }  // container prefix-metric
                  }  // list flex-algo
                }  // container flex-algos
    
                container affinity-maps {
                  description
                    "Affinity map configuration";
                  list affinity-map {
                    key "affinity-map-name";
                    description
                      "Affinity map configuration";
                    leaf affinity-map-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Affinity map configuration";
                    }
    
                    leaf bit-position {
                      type uint32 {
                        range "0..255";
                      }
                      mandatory true;
                      description
                        "Bit position for affinity attribute value";
                    }
                  }  // list affinity-map
                }  // container affinity-maps
    
                container srlg {
                  presence
                    "Indicates a srlg node is configured.";
                  description
                    "ISIS SRLG submode";
                  container names {
                    description "SRLG Name";
                    list name {
                      key "srlg-name";
                      description "SRLG Name";
                      leaf srlg-name {
                        type xr:Cisco-ios-xr-string {
                          length "1..64";
                        }
                        description "SRLG Name";
                      }
    
                      leaf admin-weight {
                        type uint32 {
                          range "0..16777215";
                        }
                        description
                          "Administrative weight: default inherited from the global admin-weight";
                      }
    
                      container static {
                        description
                          "Configure static SRLG under name";
                        container ipv4 {
                          description
                            "IPv4 address";
                          list address {
                            must "next-hop";
                            key "local-address";
                            description
                              "IPv4 address of local end-point of the link";
                            leaf local-address {
                              type inet:ipv4-address-no-zone;
                              description
                                "IPv4 address of local end-point of the link";
                            }
    
                            container next-hop {
                              description
                                "Next hop of the link";
                              list address {
                                key "remote-address";
                                description
                                  "IPv4 address of local end-point of the link";
                                leaf remote-address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "IPv4 address of remote end-point of the link";
                                }
                              }  // list address
                            }  // container next-hop
                          }  // list address
                        }  // container ipv4
                      }  // container static
                    }  // list name
                  }  // container names
    
                  leaf admin-weight {
                    type uint32 {
                      range "0..16777215";
                    }
                    description
                      "Default administrative weight for all SRLGs, default is 1";
                  }
                }  // container srlg
    
                container purge-transmit {
                  description
                    "Control TLVs permitted in purge LSP";
                  container strict {
                    presence
                      "Indicates a strict node is configured.";
                    description
                      "Only authentication TLV is allowed";
                    leaf apply-for-level-only {
                      type enumeration {
                        enum "level-1" {
                          value 1;
                          description
                            "Apply for Level-1 only";
                        }
                        enum "level-2" {
                          value 2;
                          description
                            "Apply for Level-2 only";
                        }
                      }
                      description
                        "configure this node";
                    }
                  }  // container strict
                }  // container purge-transmit
    
                container receive {
                  description
                    "Control if ASLA takes precedence over Legacy";
                  container application {
                    description
                      "Select Application";
                    container flex-algo {
                      description
                        "Flex-Algo Applciation";
                      container delay {
                        description
                          "Unidirectionial Min Delay metric";
                        container app-only {
                          presence
                            "Indicates a app-only node is configured.";
                          description
                            "ASLA to take precedence";
                        }  // container app-only
                      }  // container delay
                    }  // container flex-algo
                  }  // container application
                }  // container receive
    
                container attestation {
                  presence
                    "Indicates a attestation node is configured.";
                  description
                    "ISIS Attestation submode";
                  container application {
                    description "Application";
                    container flex-algo {
                      presence
                        "Indicates a flex-algo node is configured.";
                      description
                        "Flexible Algorithm application";
                      container trust-vector {
                        presence
                          "Indicates a trust-vector node is configured.";
                        description
                          "Trust Vector Configuration";
                        container boot-integrity-passed {
                          description
                            "Boot Integrity Passed";
                          leaf affinity {
                            type string {
                              length "1..32";
                            }
                            description
                              "Affinity configuration";
                          }
                        }  // container boot-integrity-passed
    
                        container boot-integrity-failed {
                          description
                            "Boot Integrity Failed";
                          leaf affinity {
                            type string {
                              length "1..32";
                            }
                            description
                              "Affinity configuration";
                          }
                        }  // container boot-integrity-failed
    
                        container failures-found {
                          description
                            "Failures Found";
                          leaf affinity {
                            type string {
                              length "1..32";
                            }
                            description
                              "Affinity configuration";
                          }
                        }  // container failures-found
                      }  // container trust-vector
                    }  // container flex-algo
    
                    container traffic-engineering {
                      presence
                        "Indicates a traffic-engineering node is configured.";
                      description
                        "Traffic-engineering application";
                      container trust-vector {
                        presence
                          "Indicates a trust-vector node is configured.";
                        description
                          "Trust Vector Configuration";
                        container boot-integrity-passed {
                          description
                            "Boot Integrity Passed";
                          leaf affinity {
                            type string {
                              length "1..32";
                            }
                            description
                              "Affinity configuration";
                          }
                        }  // container boot-integrity-passed
    
                        container boot-integrity-failed {
                          description
                            "Boot Integrity Failed";
                          leaf affinity {
                            type string {
                              length "1..32";
                            }
                            description
                              "Affinity configuration";
                          }
                        }  // container boot-integrity-failed
    
                        container failures-found {
                          description
                            "Failures Found";
                          leaf affinity {
                            type string {
                              length "1..32";
                            }
                            description
                              "Affinity configuration";
                          }
                        }  // container failures-found
                      }  // container trust-vector
                    }  // container traffic-engineering
                  }  // container application
                }  // container attestation
              }  // list process
            }  // container processes
          }  // container isis
        }  // container router
      }  // module Cisco-IOS-XR-um-router-isis-cfg
    

© 2023 YumaWorks, Inc. All rights reserved.