submodule Cisco-IOS-XR-infra-xtc-agent-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-infra-xtc-agent-oper {
        prefix
          Cisco-IOS-XR-infra-xtc-agent-oper;
    }

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

    include Cisco-IOS-XR-infra-xtc-agent-oper-sub2 {
      revision-date "2021-05-21";
    }

    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 submodule contains a collection of YANG definitions
     for Cisco IOS-XR infra-xtc-agent package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-05-21" {
      description
        "Added path invalidation drop flag in policy bag.
       2021-04-22
         Added TE metric field for Flex-algo ASLA.
       2021-02-18
         Remove deprecated performance-measurement oper bag and renamed pm config field name in xtc_pm_lsp_info. Added performance-measurement config data bag in lsp bag.
       2021-02-08
         Added performance-measurement config data bag in lsp bag.
       2020-12-13
         Added performance-measurement liveness-detection oper schema.
       2020-10-27
         Added A flag set field in show command to support A flag sent from PM side
       2020-09-16
         Adding operational nodes for new features path invalidation drop protected and unprotected path
       2020-09-04
         Modified the Extended-Affinities and ASLA-Extended-Affinities to be list instead of a leaf-list
       2020-05-12
         Add SRv6TE policy operational data
       2020-05-05
         changes related to treat SRv6 and SID as well-known when parsing XML for yang";
    }

    revision "2020-01-16" {
      description
        "Removed event buffer from SR-TE policy model. Implement new statistic info for policy performance-measurement session. Added support for per-flow policy output. Added additional filter for policy type i.e. per-flow and per-destination.";
    }

    revision "2019-09-09" {
      description
        "PCE/SRTE topology should display P-flag set for OSPF prefix-SID with explicit-null";
    }

    revision "2019-05-01" {
      description
        "Added operational models for interface database.";
    }

    revision "2019-04-15" {
      description
        "Hierarchical changes to policy forwarding model to organize the paths under the proper segment lists and LSPs.";
    }

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

    revision "2018-11-28" {
      description
        "Various modifications to policy-related models for better compatibility with the IETF policy draft.";
    }

    revision "2017-09-11" {
      description "Initial version";
    }

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

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

    typedef Cmn-ha-case {
      type enumeration {
        enum "ha-case-migration" {
          value 0;
          description "HA Case Migration";
        }
        enum "ha-case-restart" {
          value 1;
          description "HA Case Restart";
        }
        enum "ha-case-switchover" {
          value 2;
          description "HA Case Switchover";
        }
        enum "ha-case-startup" {
          value 3;
          description "HA Case Startup";
        }
        enum "ha-case-invalid" {
          value 4;
          description "HA Case Invalid";
        }
      }
      description "Various HA cases";
    }

    typedef Xtc-sid1 {
      type enumeration {
        enum "sr-protected-adj-sid" {
          value 1;
          description
            "Protected Adjacency SID";
        }
        enum "sr-unprotected-adj-sid" {
          value 2;
          description
            "Unprotected Adjacency SID";
        }
        enum
          "sr-bgp-egress-peer-engineering-sid" {
          value 3;
          description
            "BGP egress peer engineering SID";
        }
        enum "sr-reqular-prefix-sid" {
          value 4;
          description "Regular prefix SID";
        }
        enum "sr-strict-prefix-sid" {
          value 5;
          description "Strict prefix SID";
        }
        enum "sr-flex-algo-prefix-sid" {
          value 6;
          description "Flex-algo prefix SID";
        }
      }
      description "XTC SID Types";
    }

    typedef Xtc-regist-entry {
      type enumeration {
        enum "color" {
          value 0;
          description "Color";
        }
        enum "color-endpoint" {
          value 1;
          description "Color Endpoint";
        }
        enum "policy-name" {
          value 2;
          description "PolicyName";
        }
      }
      description "Xtc regist entry";
    }

    typedef Xtc-igp-info-id {
      type enumeration {
        enum "isis" {
          value 1;
          description "ISIS";
        }
        enum "ospf" {
          value 2;
          description "OSPF";
        }
        enum "bgp" {
          value 3;
          description "BGP";
        }
      }
      description "IGP IDs";
    }

    typedef Xtc-disjointness {
      type enumeration {
        enum "no-disjointness" {
          value 0;
          description "No Disjointness";
        }
        enum "link-disjointness" {
          value 1;
          description "Link disjointness";
        }
        enum "node-disjointness" {
          value 2;
          description "Node disjointness";
        }
        enum "srlg-disjointness" {
          value 3;
          description "SRLG disjointness";
        }
        enum "srlg-node-disjointness" {
          value 4;
          description
            "SRLG-Node disjointness";
        }
      }
      description "XTC policy path type";
    }

    typedef Mgmt-srv6-sid-fmt {
      type enumeration {
        enum "none" {
          value 0;
          description "No format";
        }
        enum "base" {
          value 1;
          description "Base Format";
        }
        enum "f3216" {
          value 2;
          description
            "Micro-segment F3216 Format";
        }
      }
      description "SRv6 SID Format Type";
    }

    typedef Mgmt-srv6-endpoint {
      type enumeration {
        enum "unknown" {
          value 0;
          description
            "Unknown Endpoint type";
        }
        enum "end" {
          value 1;
          description "End (no PSP/USP)";
        }
        enum "end-with-psp" {
          value 2;
          description "End with PSP";
        }
        enum "end-with-usp" {
          value 3;
          description "End with USP";
        }
        enum "end-with-psp-usp" {
          value 4;
          description "End with PSP/USP";
        }
        enum "end-x" {
          value 5;
          description "End.X (no PSP/USP)";
        }
        enum "end-x-with-psp" {
          value 6;
          description "End.X with PSP";
        }
        enum "end-x-with-usp" {
          value 7;
          description "End.X with USP";
        }
        enum "end-x-with-psp-usp" {
          value 8;
          description "End.X with PSP/USP";
        }
        enum "end-tbl" {
          value 9;
          description "End.T (no PSP/USP)";
        }
        enum "end-tbl-with-psp" {
          value 10;
          description "End.T with PSP";
        }
        enum "end-tbl-with-usp" {
          value 11;
          description "End.T with USP";
        }
        enum "end-tbl-with-psp-usp" {
          value 12;
          description "End.T with PSP/USP";
        }
        enum "end-b6-insert" {
          value 13;
          description "End.B6.Insert";
        }
        enum "end-b6-encaps" {
          value 14;
          description "End.B6.Encaps";
        }
        enum "end-bm" {
          value 15;
          description "End.BM";
        }
        enum "end-dx6" {
          value 16;
          description "End.DX6";
        }
        enum "end-dx4" {
          value 17;
          description "End.DX4";
        }
        enum "end-dt6" {
          value 18;
          description "End.DT6";
        }
        enum "end-dt4" {
          value 19;
          description "End.DT4";
        }
        enum "end-dt46" {
          value 20;
          description "End.DT46";
        }
        enum "end-dx2" {
          value 21;
          description "End.DX2";
        }
        enum "end-dx2v" {
          value 22;
          description "End.DX2V";
        }
        enum "end-dt2u" {
          value 23;
          description "End.DT2U";
        }
        enum "end-dt2m" {
          value 24;
          description "End.DT2M";
        }
        enum "end-s" {
          value 25;
          description "End.S";
        }
        enum "end-b6-insert-red" {
          value 26;
          description
            "End.B6.Insert.Reduced";
        }
        enum "end-b6-encaps-red" {
          value 27;
          description
            "End.B6.Encaps.Reduced";
        }
        enum "end-with-usd" {
          value 28;
          description "End with USD";
        }
        enum "end-with-psp-usd" {
          value 29;
          description "End with PSP/USD";
        }
        enum "end-with-usp-usd" {
          value 30;
          description "End with USP/USD";
        }
        enum "end-with-psp-usp-usd" {
          value 31;
          description "End with PSP/USP/USD";
        }
        enum "end-x-with-usd" {
          value 32;
          description "End.X with USD";
        }
        enum "end-x-with-psp-usd" {
          value 33;
          description "End.X with PSP/USD";
        }
        enum "end-x-with-usp-usd" {
          value 34;
          description "End.X with USP/USD";
        }
        enum "end-x-with-psp-usp-usd" {
          value 35;
          description
            "End.X with PSP/USP/USD";
        }
        enum "end-tbl-with-usd" {
          value 36;
          description "End.T with USD";
        }
        enum "end-tbl-with-psp-usd" {
          value 37;
          description "End.T with PSP/USD";
        }
        enum "end-tbl-with-usp-usd" {
          value 38;
          description "End.T with USP/USD";
        }
        enum "end-tbl-with-psp-usp-usd" {
          value 39;
          description
            "End.T with PSP/USP/USD";
        }
        enum "end-op" {
          value 40;
          description "End.OP";
        }
        enum "end-otp" {
          value 41;
          description "End.OTP";
        }
        enum "un-shift-only" {
          value 42;
          description "uN Shift-only";
        }
        enum "un" {
          value 43;
          description "uN";
        }
        enum "un-psp" {
          value 44;
          description "uN with PSP";
        }
        enum "un-usp" {
          value 45;
          description "uN with USP";
        }
        enum "un-psp-usp" {
          value 46;
          description "uN with PSP-USP";
        }
        enum "un-usd" {
          value 47;
          description "uN with USD";
        }
        enum "un-psp-usd" {
          value 48;
          description "uN with PSP-USD";
        }
        enum "un-usp-usd" {
          value 49;
          description "uN with USP-USD";
        }
        enum "un-psp-usp-usd" {
          value 50;
          description "uN with PSP_USP-USD";
        }
        enum "ua-shift-only" {
          value 51;
          description "uA Shift-only";
        }
        enum "ua" {
          value 52;
          description "uA";
        }
        enum "ua-psp" {
          value 53;
          description "uA with PSP";
        }
        enum "ua-usp" {
          value 54;
          description "uA with USP";
        }
        enum "ua-psp-usp" {
          value 55;
          description "uA with PSP-USP";
        }
        enum "ua-usd" {
          value 56;
          description "uA with USD";
        }
        enum "ua-psp-usd" {
          value 57;
          description "uA with PSP-USD";
        }
        enum "ua-usp-usd" {
          value 58;
          description "uA with USP-USD";
        }
        enum "ua-psp-usp-usd" {
          value 59;
          description "uA with PSP_USP-USD";
        }
        enum "udx6" {
          value 60;
          description "uDX6";
        }
        enum "udx4" {
          value 61;
          description "uDX4";
        }
        enum "udt6" {
          value 62;
          description "uDT6";
        }
        enum "udt4" {
          value 63;
          description "uDT4";
        }
        enum "udt46" {
          value 64;
          description "uDT46";
        }
        enum "udx2" {
          value 65;
          description "uDX2";
        }
        enum "udx2v" {
          value 66;
          description "uDX2V";
        }
        enum "udt2u" {
          value 67;
          description "uDT2U";
        }
        enum "udt2m" {
          value 68;
          description "uDT2M";
        }
        enum "ub6-insert" {
          value 69;
          description "uB6 Insert";
        }
        enum "ub6-encaps" {
          value 70;
          description "uB6 Encaps";
        }
        enum "ub6-insert-red" {
          value 71;
          description "uB6 Insert.Red";
        }
        enum "ub6-encaps-red" {
          value 72;
          description "uB6 Encaps.Red";
        }
        enum "ubm" {
          value 73;
          description "uBM";
        }
      }
      description
        "SRv6 Endpoint Behavior Type";
    }

    typedef Xtc-treesid-role {
      type enumeration {
        enum "none" {
          value 0;
          description "No role";
        }
        enum "ingress" {
          value 1;
          description "Ingress";
        }
        enum "transit" {
          value 2;
          description "Transit";
        }
        enum "egress" {
          value 3;
          description "Egress";
        }
        enum "bud-node" {
          value 4;
          description "BudNode";
        }
      }
      description "XTC TreeSID role";
    }

    typedef Xtc-pfp-state {
      type enumeration {
        enum "initialized" {
          value 0;
          description "Initialized";
        }
        enum "bsid-rewrite-pending" {
          value 1;
          description
            "Waiting for BSID rewrite result";
        }
        enum "up" {
          value 2;
          description "Up";
        }
        enum "bsid-reoptimizing" {
          value 3;
          description
            "Waiting for reoptimized BSID rewrite result";
        }
      }
      description
        "XTC Per-flow Policy FSM states";
    }

    typedef Xtc-pm-live-session-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "down" {
          value 1;
          description "Down";
        }
        enum "up" {
          value 2;
          description "Up";
        }
      }
      description
        "Xtc pm live session state";
    }

    typedef Xtc-bfd-session-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "down" {
          value 1;
          description "Down";
        }
        enum "up" {
          value 2;
          description "Up";
        }
      }
      description "Xtc bfd session state";
    }

    typedef Xtc-policy-lsp-sm-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "initialized" {
          value 1;
          description "Initialized";
        }
        enum "deleted" {
          value 2;
          description "Deleted";
        }
        enum "programmed" {
          value 3;
          description
            "Programmed; all forwarding rewrites created";
        }
        enum "egress-paths-pending" {
          value 4;
          description
            "Waiting for egress paths";
        }
        enum "out-of-resources-pending" {
          value 5;
          description
            "Waiting for resources to become available";
        }
        enum "label-allocation-pending" {
          value 6;
          description
            "Waiting for label allocation result";
        }
        enum
          "label-allocation-cleanup-pending" {
          value 7;
          description
            "Waiting for label free result";
        }
        enum "label-rewrite-pending" {
          value 8;
          description
            "Waiting for label rewrite create result";
        }
        enum "label-rewrite-cleanup-pending" {
          value 9;
          description
            "Waiting for label rewrite delete result";
        }
        enum "bsid-allocation-pending" {
          value 10;
          description
            "Waiting for BSID label allocation result";
        }
        enum
          "bsid-allocation-cleanup-pending" {
          value 11;
          description
            "Waiting for BSID label free result";
        }
        enum "bsid-rewrite-pending" {
          value 12;
          description
            "Waiting for BSID rewrite create result";
        }
        enum "bsid-rewrite-cleanup-pending" {
          value 13;
          description
            "Waiting for BSID rewrite delete result";
        }
        enum "tunnel-rewrite-pending" {
          value 14;
          description
            "Waiting for tunnel rewrite create result";
        }
        enum
          "tunnel-rewrite-cleanup-pending" {
          value 15;
          description
            "Waiting for tunnel rewrite delete result";
        }
        enum "install-timer-pending" {
          value 16;
          description
            "Waiting for install timer to expire";
        }
        enum "cleanup-timer-pending" {
          value 17;
          description
            "Waiting for cleanup timer to expire";
        }
        enum "bfd-session-pending" {
          value 18;
          description
            "Waiting for BFD session to come up";
        }
        enum "pm-liveness-session-pending" {
          value 19;
          description
            "Waiting for PM liveness session to come up";
        }
        enum "invalidated-traffic-dropped" {
          value 20;
          description
            "Path invalidated, policy remains up but traffic
           dropped";
        }
      }
      description
        "XTC policy LSP FSM states";
    }

    typedef Xtc-pm-live-invalidation-action {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "down" {
          value 1;
          description "Down";
        }
      }
      description
        "Xtc pm live invalidation action";
    }

    typedef Xtc-bfd-invalidation-action {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "down" {
          value 1;
          description "Down";
        }
      }
      description
        "Xtc bfd invalidation action";
    }

    typedef Xtc-path-protection {
      type enumeration {
        enum "protected-preferred" {
          value 0;
          description "Protected Preferred";
        }
        enum "unprotected-only" {
          value 1;
          description "Unprotected Only";
        }
        enum "protected-only" {
          value 2;
          description "Protected Only";
        }
        enum "unprotected-preferred" {
          value 3;
          description
            "Unprotected Preferred";
        }
      }
      description "XTC path protection type";
    }

    typedef Xtc-sr-sid {
      type enumeration {
        enum "ipv4-node-sid" {
          value 0;
          description "IPv4 Node SID";
        }
        enum "ipv4-adjacency-sid" {
          value 1;
          description "IPv4 Adjacency SID";
        }
        enum "ipv4-unnumbered-adjacency-sid" {
          value 2;
          description
            "IPv4 Unnumbered Adjacency SID";
        }
        enum "ipv6-node-sid" {
          value 3;
          description "IPv6 Node SID";
        }
        enum "ipv6-adjacency-sid" {
          value 4;
          description "IPv6 Adjacency SID";
        }
        enum "srv6usid" {
          value 5;
          description "SRv6 USID";
        }
        enum "ipv6-link-local-adjacency-sid" {
          value 6;
          description
            "IPv6 Link Local Adjacency SID";
        }
        enum "unknown-sid" {
          value 7;
          description "Unknown SID";
        }
      }
      description "XTC SR SID type";
    }

    typedef Xtc-policy-path {
      type enumeration {
        enum "explicit" {
          value 0;
          description "Explicit path";
        }
        enum "dynamic" {
          value 1;
          description "Dynamic path";
        }
        enum "dynamic-pce" {
          value 2;
          description
            "Dynamic PCE-based path";
        }
      }
      description "XTC policy path type";
    }

    typedef Xtc-policy-cpath-proto-origin {
      type enumeration {
        enum "unknown" {
          value 0;
          description "unknown";
        }
        enum "xtc" {
          value 5;
          description "xtc";
        }
        enum "pcep" {
          value 10;
          description "pcep";
        }
        enum "bgp" {
          value 20;
          description "bgp";
        }
        enum "configuration" {
          value 30;
          description "configuration";
        }
      }
      description
        "Policy candidate path protocol origin";
    }

    typedef Cmn-metric {
      type enumeration {
        enum "metric-type-none" {
          value 0;
          description "Metric Type None";
        }
        enum "metric-type-igp" {
          value 1;
          description "Metric Type IGP";
        }
        enum "metric-type-te" {
          value 2;
          description "Metric Type TE";
        }
        enum "metric-type-hop-count" {
          value 3;
          description
            "Metric Type hop count";
        }
        enum "metric-type-msd" {
          value 11;
          description "Metric Type MSD";
        }
        enum "metric-type-latency" {
          value 12;
          description "Metric Type latency";
        }
      }
      description "PCE Metric Type";
    }

    typedef Xtc-af-id {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "ipv4" {
          value 1;
          description "IPv4";
        }
        enum "ipv6" {
          value 2;
          description "IPv6";
        }
      }
      description "Xtc af id";
    }

    grouping XTC-INTERFACE-SUMMARY-BAG {
      description
        "XTC interface summary information";
      leaf interface-count {
        type uint32;
        description "Number of interfaces";
      }

      leaf interface-operational-up-count {
        type uint32;
        description
          "Number of interfaces that are operationally up";
      }

      leaf interface-operational-down-count {
        type uint32;
        description
          "Number of interfaces that are operationally down";
      }
    }  // grouping XTC-INTERFACE-SUMMARY-BAG

    grouping XTC-PFX-ENTRY {
      description "XTC prefix etnry";
      container ip-address {
        description "Prefix IP address";
        uses XTC-IP-ADDR-TYPE;
      }  // container ip-address
    }  // grouping XTC-PFX-ENTRY

    grouping XTC-PFX-BAG {
      description "XTC Prefix Information";
      container node-protocol-identifier {
        description
          "Node protocol identifier";
        uses XTC-NODE-PID-BAG;
      }  // container node-protocol-identifier

      leaf node-identifier-xr {
        type uint32;
        description "Node identifier";
      }

      list address {
        description "Prefix address";
        uses XTC-PFX-ENTRY;
      }  // list address
    }  // grouping XTC-PFX-BAG

    grouping XTC-TOPO-READY-BAG {
      description
        "XTC Topology Readiness Information";
      container timer {
        description
          "Topology readiness timer";
        uses CMN-TIMER-INFO;
      }  // container timer

      leaf ready {
        type boolean;
        description "Topology readiness";
      }

      leaf ha-case {
        type Cmn-ha-case;
        description "Last HA case";
      }

      leaf timer-value {
        type uint32;
        description
          "Topology ready timer value selected at start";
      }

      leaf pcep-allowed {
        type boolean;
        description
          "Whether PCEP is allowed";
      }
    }  // grouping XTC-TOPO-READY-BAG

    grouping XTC-TOPO-SUMMARY-BAG {
      description
        "XTC Topology Node Summary Information";
      container topology-ready-summary {
        description "Topology ready summary";
        uses XTC-TOPO-READY-BAG;
      }  // container topology-ready-summary

      leaf nodes {
        type uint32;
        description "Number of nodes";
      }

      leaf prefixes {
        type uint32;
        description "Number of prefixes";
      }

      leaf prefix-sids {
        type uint32;
        description "Number of prefix SIDs";
      }

      leaf links {
        type uint32;
        description "Number of links";
      }

      leaf adjacency-sids {
        type uint32;
        description
          "Number of adjacency SIDs";
      }
    }  // grouping XTC-TOPO-SUMMARY-BAG

    grouping XTC-IPV6-LINK-BAG {
      description
        "XTC IPv6 Link Information";
      container local-igp-information {
        description
          "Local node IGP information";
        uses XTC-IGP-INFO-BAG;
      }  // container local-igp-information

      container remote-node-protocol-identifier {
        description
          "Remote node protocol identifier";
        uses XTC-NODE-PID-BAG;
      }  // container remote-node-protocol-identifier

      leaf local-ipv6-address {
        type inet:ipv6-address;
        description "Local IPv6 address";
      }

      leaf remote-ipv6-address {
        type inet:ipv6-address;
        description "Remote IPv6 address";
      }

      leaf igp-metric {
        type uint32;
        description "IGP Metric";
      }

      leaf te-metric {
        type uint32;
        description "TE Metric";
      }

      leaf maximum-link-bandwidth {
        type uint64;
        description "Max link bandwidth";
      }

      leaf max-reservable-bandwidth {
        type uint64;
        description
          "Max Reservable bandwidth";
      }

      leaf flex-algo-te-metric {
        type uint32;
        description
          "Flex-algo specific TE metric value";
      }

      list adjacency-sid {
        description "Adjacency SIDs";
        uses XTC-SID-BAG;
      }  // list adjacency-sid
    }  // grouping XTC-IPV6-LINK-BAG

    grouping XTC-LINK-PM-METRICS {
      description
        "Link performance metric information";
      leaf unidirectional-minimum-delay-microseconds {
        type uint32;
        units "microsecond";
        description
          "Min delay in microseconds";
      }
    }  // grouping XTC-LINK-PM-METRICS

    grouping XTC-IPV4-LINK-BAG {
      description
        "XTC IPv4 Link Information";
      container local-igp-information {
        description
          "Local node IGP information";
        uses XTC-IGP-INFO-BAG;
      }  // container local-igp-information

      container remote-node-protocol-identifier {
        description
          "Remote node protocol identifier";
        uses XTC-NODE-PID-BAG;
      }  // container remote-node-protocol-identifier

      container performance-metrics {
        description "Performance metrics";
        uses XTC-LINK-PM-METRICS;
      }  // container performance-metrics

      leaf is-unnumbered {
        type boolean;
        description
          "True if this is an IPv4 Unnumbered link";
      }

      leaf local-interface-index {
        type uint32;
        description
          "SNMP index of local interface: non-zero if
         IsUnnumbered is True";
      }

      leaf remote-interface-index {
        type uint32;
        description
          "SNMP index of remote interface: non-zero if
         IsUnnumbered is True";
      }

      leaf local-ipv4-address {
        type inet:ipv4-address;
        description "Local IPv4 address";
      }

      leaf remote-ipv4-address {
        type inet:ipv4-address;
        description "Remote IPv4 address";
      }

      leaf igp-metric {
        type uint32;
        description "IGP Metric";
      }

      leaf te-metric {
        type uint32;
        description "TE Metric";
      }

      leaf maximum-link-bandwidth {
        type uint64;
        description "Max link bandwidth";
      }

      leaf max-reservable-bandwidth {
        type uint64;
        description
          "Max Reservable bandwidth";
      }

      leaf administrative-groups {
        type uint32;
        description "Link admin-groups";
      }

      leaf flex-algo-te-metric {
        type uint32;
        description
          "Flex-algo specific TE metric value";
      }

      leaf-list srlgs {
        type uint32;
        description "SRLG Values";
      }

      list extended-administrative-group {
        description
          "Link Extended admin-groups";
        leaf entry {
          type uint32;
          description
            "Link Extended admin-groups";
        }
      }  // list extended-administrative-group

      list adjacency-sid {
        description "Adjacency SIDs";
        uses XTC-SID-BAG;
      }  // list adjacency-sid

      list flex-algo-asla-administrative-group {
        description
          "Flex-algo specific Link Extended admin-groups";
        leaf entry {
          type uint32;
          description
            "Flex-algo specific Link Extended admin-groups";
        }
      }  // list flex-algo-asla-administrative-group
    }  // grouping XTC-IPV4-LINK-BAG

    grouping XTC-SID-BAG {
      description "XTC SID bags";
      container sid-prefix {
        description "Prefix";
        uses XTC-IP-ADDR-TYPE;
      }  // container sid-prefix

      leaf sid-type {
        type Xtc-sid1;
        description "SID Type";
      }

      leaf algorithm {
        type uint32;
        description
          "Prefix-SID algorithm number";
      }

      leaf mpls-label {
        type uint32;
        description "MPLS Label";
      }

      leaf xflag {
        type boolean;
        description "X Flag";
      }

      leaf rflag {
        type boolean;
        description "R Flag";
      }

      leaf nflag {
        type boolean;
        description "N Flag";
      }

      leaf pflag {
        type boolean;
        description "P Flag";
      }

      leaf eflag {
        type boolean;
        description "E Flag";
      }

      leaf vflag {
        type boolean;
        description "V Flag";
      }

      leaf lflag {
        type boolean;
        description "L Flag";
      }

      leaf mflag {
        type boolean;
        description "M Flag";
      }
    }  // grouping XTC-SID-BAG

    grouping XTC-NODE-PID-BAG {
      description
        "XTC Node Protocol Identifier Information";
      leaf node-name {
        type string;
        description "Node Name";
      }

      leaf ipv4-bgp-router-id-set {
        type boolean;
        description
          "True if IPv4 BGP router ID is set";
      }

      leaf ipv4-bgp-router-id {
        type inet:ipv4-address;
        description "IPv4 TE router ID";
      }

      leaf ipv4te-router-id-set {
        type boolean;
        description
          "True if IPv4 TE router ID is set";
      }

      leaf ipv4te-router-id {
        type inet:ipv4-address;
        description "IPv4 BGP router ID";
      }

      list igp-information {
        description "IGP information";
        uses XTC-IGP-INFO-BAG;
      }  // list igp-information
    }  // grouping XTC-NODE-PID-BAG

    grouping XTC-TOPO-NODE-BAG {
      description
        "XTC Topology Node Information";
      container node-protocol-identifier {
        description
          "Node protocol identifier";
        uses XTC-NODE-PID-BAG;
      }  // container node-protocol-identifier

      leaf node-identifier-xr {
        type uint32;
        description "Node identifier";
      }

      leaf overload {
        type boolean;
        description "Node Overload Bit";
      }

      list prefix-sid {
        description "Prefix SIDs";
        uses XTC-SID-BAG;
      }  // list prefix-sid

      list ipv4-link {
        description "IPv4 Link information";
        uses XTC-IPV4-LINK-BAG;
      }  // list ipv4-link

      list ipv6-link {
        description "IPv6 Link information";
        uses XTC-IPV6-LINK-BAG;
      }  // list ipv6-link

      list srv6-sid {
        description "SRv6 END SIDs";
        uses XTC-SRV6-SID-BAG;
      }  // list srv6-sid
    }  // grouping XTC-TOPO-NODE-BAG

    grouping XTC-REGIST-CONTENT-BAG {
      description "Regist entry content";
      leaf-list client-id {
        type uint32;
        description
          "Clients that registered";
      }
    }  // grouping XTC-REGIST-CONTENT-BAG

    grouping XTC-REGIST-KEY-BAG {
      description "Regist entry key";
      container endpoint {
        description "Policy endpoint";
        uses XTC-IP-ADDR-TYPE;
      }  // container endpoint

      leaf type {
        type Xtc-regist-entry;
        description "Type of registration";
      }

      leaf color {
        type uint32;
        description "Color";
      }

      leaf policy-name {
        type string;
        description "Policy name";
      }
    }  // grouping XTC-REGIST-KEY-BAG

    grouping XTC-REGIST-ENTRY-BAG {
      description "Regist entry";
      container key {
        description "Entry key";
        uses XTC-REGIST-KEY-BAG;
      }  // container key

      container content {
        description "Entry content";
        uses XTC-REGIST-CONTENT-BAG;
      }  // container content
    }  // grouping XTC-REGIST-ENTRY-BAG

    grouping XTC-CONTROLLER-POLICY-REQ-BAG {
      description
        "Controller policy request";
      container end-point {
        description "End point";
        uses XTC-IP-ADDR-TYPE;
      }  // container end-point

      leaf source-address-xr {
        type inet:ipv4-address;
        description "Source address";
      }

      leaf binding-sid {
        type uint32;
        description "Binding SID";
      }

      leaf preference {
        type uint32;
        description "Preference";
      }

      leaf color-xr {
        type uint32;
        description "Color";
      }

      leaf route-distinguisher-xr {
        type uint32;
        description "Route distinguisher";
      }

      leaf creation-time {
        type uint32;
        units "second";
        description
          "Creation time of the request in seconds";
      }

      leaf last-updated-time {
        type uint32;
        units "second";
        description
          "Last updated time of the request in seconds";
      }

      list segment-list {
        description "Segment lists";
        uses XTC-POLICY-SL-BAG;
      }  // list segment-list
    }  // grouping XTC-CONTROLLER-POLICY-REQ-BAG

    grouping XTC-IGP-INFO-BGP {
      description "XTC BGP Information";
      leaf router-id {
        type Xtc-ipv4-address;
        description "BGP router ID";
      }
    }  // grouping XTC-IGP-INFO-BGP

    grouping XTC-IGP-INFO-OSPF {
      description "XTC OSPF Information";
      leaf router-id {
        type Xtc-ipv4-address;
        description "OSPF router ID";
      }

      leaf area {
        type uint32;
        description "OSPF area";
      }
    }  // grouping XTC-IGP-INFO-OSPF

    grouping XTC-IGP-INFO-ISIS {
      description "XTC ISIS Information";
      leaf system-id {
        type string;
        description "ISIS system ID";
      }

      leaf level {
        type uint32;
        description "ISIS level";
      }
    }  // grouping XTC-IGP-INFO-ISIS

    grouping XTC-IGP-INFO-TYPE {
      description "XTC IGP INFO TYPE";
      container isis {
        when "../igp-id = 'isis'" {
          description "../IGP_ID = 'ISIS'";
        }
        description "ISIS information";
        uses XTC-IGP-INFO-ISIS;
      }  // container isis

      container ospf {
        when "../igp-id = 'ospf'" {
          description "../IGP_ID = 'OSPF'";
        }
        description "OSPF information";
        uses XTC-IGP-INFO-OSPF;
      }  // container ospf

      container bgp {
        when "../igp-id = 'bgp'" {
          description "../IGP_ID = 'BGP'";
        }
        description "BGP information";
        uses XTC-IGP-INFO-BGP;
      }  // container bgp

      leaf igp-id {
        type Xtc-igp-info-id;
        description "IGP ID";
      }
    }  // grouping XTC-IGP-INFO-TYPE

    grouping XTC-IGP-INFO-BAG {
      description "XTC IGP information bag";
      container igp {
        description
          "IGP-specific information";
        uses XTC-IGP-INFO-TYPE;
      }  // container igp

      leaf domain-identifier {
        type uint64;
        description "Domain identifier";
      }
    }  // grouping XTC-IGP-INFO-BAG

    grouping XTC-SRV6-LOCATOR-BAG {
      description "XTC SRv6 SID bag";
      leaf locator {
        type Xtc-ipv6-address;
        description "SRv6 Locator";
      }

      leaf prefix-length {
        type uint8;
        description "Prefix length";
      }

      leaf metric {
        type uint16;
        description "Metric";
      }

      leaf algorithm {
        type uint32;
        description
          "Prefix-SID algorithm number";
      }
    }  // grouping XTC-SRV6-LOCATOR-BAG

    grouping XTC-SRV6-PREFIX-BAG {
      description "XTC SRv6 Prefix bag";
      list srv6-sid {
        description "SRv6 END SIDs";
        uses XTC-SRV6-SID-BAG;
      }  // list srv6-sid

      list srv6-locator {
        description "SRv6 Locators";
        uses XTC-SRV6-LOCATOR-BAG;
      }  // list srv6-locator

      list igp-information {
        description
          "Local node IGP information";
        uses XTC-IGP-INFO-BAG;
      }  // list igp-information
    }  // grouping XTC-SRV6-PREFIX-BAG

    grouping XTC-DIST-INFO-BAG {
      description
        "Disjoint path information";
      leaf disjointness-type {
        type Xtc-disjointness;
        description "Disjointness type";
      }

      leaf group-id {
        type uint32;
        description "Group ID";
      }

      leaf sub-id {
        type uint32;
        description "Sub ID";
      }
    }  // grouping XTC-DIST-INFO-BAG

    grouping XTC-ON-DEMAND-COLOR-BAG {
      description
        "On-Demand Color information";
      container disjoint-path-info {
        description
          "Disjoint path information";
        uses XTC-DIST-INFO-BAG;
      }  // container disjoint-path-info

      container performance-measurement-configuration {
        description
          "Performance-measurement configuration";
        uses XTC-PM-CPATH-CFG-INFO;
      }  // container performance-measurement-configuration

      container per-flow-policy-config {
        description
          "Per-flow Policy Configuration Data";
        uses XTC-PFP-CONFIG-BAG;
      }  // container per-flow-policy-config

      container srv6-information {
        description
          "SRv6 policy candidate-path information";
        uses XTC-SRV6-CONFIG-BAG;
      }  // container srv6-information

      leaf color-xr {
        type uint32;
        description "Color";
      }

      leaf absolute-margin {
        type uint32;
        description "Absolute Metric Margin";
      }

      leaf relative-margin {
        type uint32;
        description
          " Relative Metric Margin";
      }

      leaf maximum-sid-depth {
        type uint32;
        description "Maximum SID Depth";
      }

      leaf config-anycast {
        type boolean;
        description "Config Anycast";
      }

      leaf igp-metric-bound {
        type uint32;
        description "IGP metric bound";
      }

      leaf te-metric-bound {
        type uint32;
        description "TE metric bound";
      }

      leaf delay-metric-bound {
        type uint32;
        description "Delay metric bound";
      }

      leaf hop-count-metric-bound {
        type uint32;
        description "Hopcount metric bound";
      }
    }  // grouping XTC-ON-DEMAND-COLOR-BAG

    grouping MGMT-SRV6-SID-FMT {
      description "SRv6 SID Format Info";
      leaf type {
        type Mgmt-srv6-sid-fmt;
        description "Format type";
      }

      leaf description {
        type string;
        description "Format description";
      }
    }  // grouping MGMT-SRV6-SID-FMT

    grouping MGMT-SRV6-ENDPOINT-BEHAVIOR {
      description
        "SRv6 Endpoint Behavior Info";
      leaf type {
        type Mgmt-srv6-endpoint;
        description "Behavior type";
      }

      leaf description {
        type string;
        description "Behavior description";
      }
    }  // grouping MGMT-SRV6-ENDPOINT-BEHAVIOR

    grouping XTC-SRV6U-LOCATOR {
      description "XTC Locator Information";
      container micro-segment-behavior {
        description "Micro-segment behavior";
        uses MGMT-SRV6-ENDPOINT-BEHAVIOR;
      }  // container micro-segment-behavior

      container sid-format {
        description "SID Format";
        uses MGMT-SRV6-SID-FMT;
      }  // container sid-format

      leaf name-xr {
        type string;
        description "Locator Name";
      }

      leaf prefix {
        type string;
        description "Locator Prefix";
      }

      leaf flex-algo {
        type uint8;
        description "FlexAlgo";
      }

      leaf is-operational {
        type boolean;
        description "Locator Status";
      }

      leaf is-oor {
        type boolean;
        description "Locator OOR Status";
      }
    }  // grouping XTC-SRV6U-LOCATOR

    grouping XTC-RIB-STATS {
      description "XTC RIB stats";
      leaf sid-alloc-count {
        type uint32;
        description "sid alloc count";
      }

      leaf sid-free-count {
        type uint32;
        description "sid free count";
      }

      leaf ub6-rw-count {
        type uint32;
        description "ub6 rw count";
      }

      leaf sid-alloc-fail-count {
        type uint32;
        description "sid alloc fail count";
      }

      leaf sid-free-fail-count {
        type uint32;
        description "sid free fail count";
      }

      leaf ub6-rw-fail-count {
        type uint32;
        description "ub6 rw fail count";
      }

      leaf sid-alloc-success-count {
        type uint32;
        description
          "sid alloc success count";
      }

      leaf sid-free-success-count {
        type uint32;
        description "sid free success count";
      }

      leaf ub6-rw-success-count {
        type uint32;
        description "ub6 rw success count";
      }

      leaf rib6-conn-up-count {
        type uint32;
        description "rib6 conn up count";
      }

      leaf rib6-conn-up-ts-first {
        type uint32;
        description "rib6 conn up ts first";
      }

      leaf rib6-conn-up-ts-last {
        type uint32;
        description "rib6 conn up ts last";
      }

      leaf rib6-conn-down-count {
        type uint32;
        description "rib6 conn down count";
      }

      leaf rib6-conn-down-ts-first {
        type uint32;
        description
          "rib6 conn down ts first";
      }

      leaf rib6-conn-down-ts-last {
        type uint32;
        description "rib6 conn down ts last";
      }
    }  // grouping XTC-RIB-STATS

    grouping XTC-PATH {
      description "XTC Path Information";
      leaf interface-handle {
        type xr:Interface-name;
        description "Interface";
      }

      leaf address {
        type Xtc-ipv6-address;
        description "Primary Address";
      }

      leaf path-id {
        type uint32;
        description "Path ID";
      }

      leaf backup-path-id {
        type uint32;
        description "Backup Path ID";
      }

      leaf flags {
        type uint32;
        description "Flags";
      }

      leaf info-source {
        type Xtc-ipv6-address;
        description "Info Source";
      }

      leaf sid-behavior {
        type uint32;
        description "SID behavior";
      }

      leaf-list backup-address {
        type Xtc-ipv6-address;
        description
          "List of Backup Addresses";
      }

      leaf-list sid {
        type Xtc-ipv6-address;
        description "Underlay SID List";
      }
    }  // grouping XTC-PATH

    grouping XTC-NEXT-HOP {
      description "XTC Next Hop Information";
      leaf prefix-xr {
        type inet:ipv6-address;
        description "Next Hop Prefix";
      }

      leaf create-time {
        type uint32;
        description "Create Time";
      }

      leaf last-update-time {
        type uint32;
        description "Last Update Time";
      }

      list paths {
        description "List of Paths";
        uses XTC-PATH;
      }  // list paths
    }  // grouping XTC-NEXT-HOP

    grouping CMN-TRACE-BUFFER-SUMMARY-BAG {
      description "Trace buffer summary";
      leaf trace-buffer-name {
        type string;
        description "Name of trace buffer";
      }

      leaf unique-trace-count {
        type uint32;
        description "Unique trace count";
      }

      leaf wrapping-trace-count-default {
        type uint32;
        description
          "Default value of wrapping trace count";
      }

      leaf wrapping-trace-count-programmed {
        type uint32;
        description
          "Programmed value of wrapping trace count";
      }

      leaf string-buffer-size-default {
        type uint32;
        units "byte";
        description
          "Default string buffer size for wrapping traces
         in bytes";
      }

      leaf string-buffer-size-programmed {
        type uint32;
        units "byte";
        description
          "Programmed string buffer size for wrapping
         traces in bytes";
      }
    }  // grouping CMN-TRACE-BUFFER-SUMMARY-BAG

    grouping XTC-EVENT-INFO {
      description "XTC Event information";
      leaf event-message {
        type string;
        description "Event message";
      }

      leaf time-stamp {
        type uint64;
        description
          "Event time, relative to Jan 1, 1970";
      }
    }  // grouping XTC-EVENT-INFO

    grouping XTC-TREESID-PIMINFO-BAG {
      description
        "P2MP policy PIM information";
      leaf rpf-id {
        type uint32;
        description
          "Reverse-path-forwarding identifier";
      }

      leaf mdt-interface-handle {
        type xr:Interface-name;
        description
          "Multicast Distribution Tree interface handle";
      }

      leaf rsi-table-id {
        type uint32;
        description
          "Router Space Infrastructure table ID";
      }
    }  // grouping XTC-TREESID-PIMINFO-BAG

    grouping XTC-TREESID-HOP-BAG {
      description "P2MP Policy hop";
      container remote-address {
        description "Remote address";
        uses XTC-IP-ADDR-TYPE;
      }  // container remote-address

      leaf outgoing-label {
        type uint32;
        description "Outgoing label";
      }

      leaf interface-handle {
        type xr:Interface-name;
        description "Interface handle";
      }

      leaf central-control-identifier {
        type uint32;
        description
          "Identifier for Central Control instructions";
      }

      leaf stale {
        type boolean;
        description
          "Whether the hop is stale";
      }

      leaf lfa-protected {
        type boolean;
        description
          "Whether the hop is protected by LFA FRR";
      }
    }  // grouping XTC-TREESID-HOP-BAG

    grouping XTC-TREESID-EP-BAG {
      description "P2MP Policy endpoint";
      container addres {
        description "Endpoint address";
        uses XTC-IP-ADDR-TYPE;
      }  // container addres

      leaf stale {
        type boolean;
        description
          "Whether the ep is stale";
      }
    }  // grouping XTC-TREESID-EP-BAG

    grouping XTC-TREESID-BAG {
      description "P2MP Policy";
      container pim-information {
        description
          "Information from PIM regarding this policy";
        uses XTC-TREESID-PIMINFO-BAG;
      }  // container pim-information

      leaf name-xr {
        type string;
        description "Policy name";
      }

      leaf root-address-xr {
        type inet:ipv4-address;
        description
          "Root address of dynamic policy";
      }

      leaf tree-id-xr {
        type uint32;
        description
          "Tree-ID of dynamic policy";
      }

      leaf lsm-id {
        type uint32;
        description "LSM Identifier";
      }

      leaf role {
        type Xtc-treesid-role;
        description "TreeSID node role";
      }

      leaf pce-creator {
        type inet:ipv4-address;
        description
          "PCE which created/updated this policy";
      }

      leaf stale {
        type boolean;
        description
          "Is this dynamic policy stale";
      }

      leaf color {
        type uint32;
        description
          "On-demand color of dynamic policy";
      }

      list end-point {
        description
          "Endpoints for dynamic policy";
        uses XTC-TREESID-EP-BAG;
      }  // list end-point

      list replication-hop {
        description "Replication points";
        uses XTC-TREESID-HOP-BAG;
      }  // list replication-hop

      list event {
        description "Events";
        uses XTC-EVENT-INFO;
      }  // list event
    }  // grouping XTC-TREESID-BAG

    grouping XTC-POLICY-SUMMARY-BAG {
      description
        "Policy summary information";
      leaf total-policy-count {
        type uint32;
        description
          "Total number of policies";
      }

      leaf up-policy-count {
        type uint32;
        description
          "Total number of policies that are operationally
         up";
      }

      leaf down-policy-count {
        type uint32;
        description
          "Total number of policies that are operationally
         down";
      }

      leaf total-candidate-path-count {
        type uint32;
        description
          "Total number of candidate paths";
      }

      leaf active-candidate-path-count {
        type uint32;
        description
          "Total number of candidate paths that are active";
      }

      leaf inactive-candidate-path-count {
        type uint32;
        description
          "Total number of candidate paths that are
         inactive";
      }

      leaf total-lsp-count {
        type uint32;
        description "Total number of LSPs";
      }

      leaf active-lsp-count {
        type uint32;
        description
          "Total number of active LSPs";
      }

      leaf reoptimized-lsp-count {
        type uint32;
        description
          "Total number of reoptimized LSPs";
      }

      leaf cleanup-lsp-count {
        type uint32;
        description
          "Total number of cleanup LSPs";
      }

      leaf oor-lsp-count {
        type uint32;
        description
          "Total number of LSPs in OOR state";
      }

      leaf pdp-count {
        type uint32;
        description
          "Total number of per-destination policies";
      }

      leaf up-pdp-count {
        type uint32;
        description
          "Total number of PDPs that are operationally up";
      }

      leaf down-pdp-count {
        type uint32;
        description
          "Total number of PDPs that are operationally down";
      }

      leaf pfp-count {
        type uint32;
        description
          "Total number of per-flow policies";
      }

      leaf up-pfp-count {
        type uint32;
        description
          "Total number of PFPs that are operationally up";
      }

      leaf down-pfp-count {
        type uint32;
        description
          "Total number of PFPs that are operationally down";
      }
    }  // grouping XTC-POLICY-SUMMARY-BAG

    grouping XTC-FWDING-EXT-INPROT-STATS-BAG {
      description
        "Extended statistics for an input protocol,
       per-path";
      list output-protocol {
        max-elements 5;
        description "Output protocol";
        uses XTC-FWDING-STATS-BAG;
      }  // list output-protocol

      list feature {
        max-elements 2;
        description "Feature";
        uses XTC-FWDING-STATS-BAG;
      }  // list feature
    }  // grouping XTC-FWDING-EXT-INPROT-STATS-BAG

    grouping XTC-FWDING-PATH-STATS-BAG {
      description
        "Extended statistics, per-path";
      list input-protocol {
        max-elements 5;
        description "Input protocol";
        uses XTC-FWDING-EXT-INPROT-STATS-BAG;
      }  // list input-protocol
    }  // grouping XTC-FWDING-PATH-STATS-BAG

    grouping XTC-SRV6-SID-BAG {
      description "XTC SRv6 SID bag";
      leaf srv6-sid {
        type Xtc-ipv6-address;
        description "SRv6 SID";
      }

      leaf sid-behavior {
        type uint16;
        description "Endpoint SID behavior";
      }

      leaf algorithm {
        type uint32;
        description
          "Prefix-SID algorithm number";
      }
    }  // grouping XTC-SRV6-SID-BAG

    grouping XTC-FWDING-POLICY-PATH-BAG {
      description
        "Policy Forwarding path information";
      container stats {
        description
          "Forwarding stats of the path (backward
         compatibility)";
        uses XTC-FWDING-STATS-BAG;
      }  // container stats

      container full-stats {
        description
          "Full forwarding stats of the path";
        uses XTC-FWDING-PATH-STATS-BAG;
      }  // container full-stats

      leaf next-hop-ipv6 {
        type Xtc-ipv6-address;
        description "IPv6 Next Hop";
      }

      leaf next-hop-table-id {
        type uint32;
        description
          "Table ID for nexthop address";
      }

      leaf is-protected {
        type boolean;
        description
          "Is this path protected ?";
      }

      leaf is-pure-bkup {
        type boolean;
        description
          "Is this path a pure backup ?";
      }

      leaf is-lfa-or-ecmp-backup {
        type boolean;
        description
          "Whether the path is LFA or ECMP backup";
      }

      leaf load-metric {
        type uint32;
        description
          "Path's load metric for load balancing";
      }

      leaf path-id {
        type uint8;
        description "path Id";
      }

      leaf bkup-path-id {
        type uint8;
        description "Backup path Id";
      }

      leaf internal-recursive-label {
        type uint32;
        description
          "Internal Recursive label";
      }

      leaf-list outgoing-interface {
        type xr:Interface-name;
        description
          "Outgoing interface handle";
      }

      leaf-list next-hop-ipv4 {
        type Xtc-ipv4-address;
        description "IPv4 Next Hop";
      }

      leaf-list label-stack {
        type uint32;
        description "Path outgoing labels";
      }

      list sid-stack {
        description "Path outgoing sids";
        uses XTC-SRV6-SID-BAG;
      }  // list sid-stack
    }  // grouping XTC-FWDING-POLICY-PATH-BAG

    grouping XTC-FWDING-POLICY-SL-BAG {
      description
        "Forwarding information related to a single
       segment list";
      container stats {
        description
          "Forwarding stats of the segment list (backward
         compatibility)";
        uses XTC-FWDING-STATS-BAG;
      }  // container stats

      container full-stats {
        description
          "Full forwarding stats of the segment list";
        uses XTC-FWDING-PATH-STATS-BAG;
      }  // container full-stats

      leaf name {
        type string;
        description
          "Name of the segment list, if any";
      }

      list forwarding-path {
        description
          "Segment list paths in forwarding";
        uses XTC-FWDING-POLICY-PATH-BAG;
      }  // list forwarding-path
    }  // grouping XTC-FWDING-POLICY-SL-BAG

    grouping XTC-FWDING-POLICY-CPATH-BAG {
      description
        "XTC FWDING POLICY CPATH BAG";
      container originator {
        description
          "Candidate path originator";
        uses XTC-POLICY-CPATH-ORIGINATOR-BAG;
      }  // container originator

      leaf name {
        type string;
        description
          "Name of the candidate path, if any";
      }

      leaf preference {
        type uint32;
        description
          "Candidate path preference";
      }

      leaf protocol-originator {
        type Xtc-policy-cpath-proto-origin;
        description
          "Candidate path protocol origin";
      }

      leaf discriminator {
        type uint32;
        description
          "Candidate path discriminator";
      }
    }  // grouping XTC-FWDING-POLICY-CPATH-BAG

    grouping XTC-FWDING-POLICY-LSP-BAG {
      description
        "Forwarding information related to a single LSP";
      container candidate-path {
        description
          "Candidate path associated with this LSP";
        uses XTC-FWDING-POLICY-CPATH-BAG;
      }  // container candidate-path

      leaf local-label {
        type uint32;
        description "Local label of the LSP";
      }

      list forwarding-segment-list {
        description
          "Segment lists installed in forwarding";
        uses XTC-FWDING-POLICY-SL-BAG;
      }  // list forwarding-segment-list
    }  // grouping XTC-FWDING-POLICY-LSP-BAG

    grouping XTC-FWDING-POLICY-BAG {
      description
        "Policy forwarding information";
      container endpoint-address {
        description "Endpoint address";
        uses XTC-IP-ADDR-TYPE;
      }  // container endpoint-address

      container binding-sid {
        description "Programmed Binding SID";
        uses XTC-PREFIX-SID-TYPE;
      }  // container binding-sid

      container stats {
        description
          "Overall forwarding stats of the policy";
        uses XTC-FWDING-STATS-BAG;
      }  // container stats

      container active-lsp {
        description "Active LSP information";
        uses XTC-FWDING-POLICY-LSP-BAG;
      }  // container active-lsp

      container reoptimized-lsp {
        description
          "Reoptimized LSP information";
        uses XTC-FWDING-POLICY-LSP-BAG;
      }  // container reoptimized-lsp

      container per-flow-information {
        description
          "Per-flow policy candidate-path information";
        uses XTC-PFP-CONFIG-BAG;
      }  // container per-flow-information

      leaf policy-name {
        type string;
        description "Policy name";
      }

      leaf color {
        type uint32;
        description "Color";
      }
    }  // grouping XTC-FWDING-POLICY-BAG

    grouping XTC-INTERFACE-BAG {
      description
        "XTC interface information";
      leaf interface-handle {
        type xr:Interface-name;
        description "Interface handle";
      }

      leaf name {
        type string;
        description "Name of the interface";
      }

      leaf operational-up {
        type boolean;
        description "Operational up";
      }
    }  // grouping XTC-INTERFACE-BAG

    grouping XTC-FS-EG-NH-BAG {
      description
        "next-hop within an egress-group of a
       first-segment";
      container next-hop-address {
        description
          "IP address of the directly connected neighbour";
        uses XTC-IP-ADDR-TYPE;
      }  // container next-hop-address

      leaf interface-handle {
        type xr:Interface-name;
        description
          "Interface handle of the outgoing interface";
      }

      leaf interface-name {
        type string;
        description
          "Name of the outgoing interface";
      }

      leaf path-id {
        type uint8;
        description "Path index for rewrite";
      }

      leaf backup-path-id {
        type uint8;
        description
          "Backup Path index for rewrite";
      }

      leaf path-flags {
        type uint16;
        description "Path flags for rewrite";
      }
    }  // grouping XTC-FS-EG-NH-BAG

    grouping XTC-FS-EG-BAG {
      description
        "egress-group within a first-segment";
      leaf next-hop-id {
        type uint32;
        description "Next-hop ID";
      }

      leaf local-label {
        type uint32;
        description
          "Internal label that points to this next-hop";
      }

      leaf needs-cleaning-up {
        type boolean;
        description
          "Cleanup to be scheduled";
      }

      leaf is-cleaning-up {
        type boolean;
        description "Cleanup in progress";
      }

      leaf rewrite-refresh-needed {
        type boolean;
        description
          "Need to refresh the rewrite";
      }

      leaf-list out-label {
        type uint32;
        description "Outgoing label stack";
      }

      list next-hop {
        description
          "Next-hops within the same egress-group";
        uses XTC-FS-EG-NH-BAG;
      }  // list next-hop
    }  // grouping XTC-FS-EG-BAG

    grouping XTC-FS-BAG {
      description
        "first-segment of an SR-TE segment-list";
      leaf first-segment-label {
        type uint32;
        description
          "First segment label as a key";
      }

      list egress-group {
        description "Groups of egress hops";
        uses XTC-FS-EG-BAG;
      }  // list egress-group
    }  // grouping XTC-FS-BAG

    grouping XTC-EFFMET-POLICY-NOTIFY-BAG {
      description
        "XTC effective metric notification";
      leaf metric-type {
        type uint8;
        description "Notified metric type";
      }

      leaf metric-value {
        type uint32;
        description "Notified metric value";
      }

      leaf admin-distance {
        type uint32;
        description
          "Notified administrative distance";
      }
    }  // grouping XTC-EFFMET-POLICY-NOTIFY-BAG

    grouping XTC-POLICY-NOTIFY-BAG {
      description
        "XTC Policy notification to clients";
      container bsid-value {
        description "Binding SID value";
        uses XTC-PREFIX-SID-TYPE;
      }  // container bsid-value

      container effective-metric {
        description
          "Information about effective metric";
        uses XTC-EFFMET-POLICY-NOTIFY-BAG;
      }  // container effective-metric

      leaf sense {
        type boolean;
        description
          "TRUE if adding, FALSE if removing";
      }

      leaf is-state-up {
        type boolean;
        description
          "Oper state of the policy";
      }

      leaf steering-disabled {
        type boolean;
        description
          "Steering is disabled for this policy";
      }

      leaf ipv6-caps {
        type boolean;
        description
          "Policy has SRv6 capability";
      }
    }  // grouping XTC-POLICY-NOTIFY-BAG

    grouping XTC-PFP-OPER-BAG {
      description
        "XTC Per-flow policy Operational Data";
      container reopt-bsid {
        description "Reoptimized BSID";
        uses XTC-POLICY-BSID-BAG;
      }  // container reopt-bsid

      leaf is-enabled {
        type boolean;
        description
          "Whether Per-flow is enabled on Policy";
      }

      leaf state {
        type Xtc-pfp-state;
        description "Per-flow Policy State";
      }

      leaf transition-count {
        type uint32;
        description "State transition count";
      }
    }  // grouping XTC-PFP-OPER-BAG

    grouping XTC-PER-FLOW-POLICY-BAG {
      description "XTC Per-flow policy";
      container pfp-config {
        description
          "Per-flow Policy Configuration Data";
        uses XTC-PFP-CONFIG-BAG;
      }  // container pfp-config

      container pfp-oper {
        description
          "Per-flow Policy Operational Data";
        uses XTC-PFP-OPER-BAG;
      }  // container pfp-oper
    }  // grouping XTC-PER-FLOW-POLICY-BAG

    grouping XTC-PFP-RW-INFO-BAG {
      description
        "XTC policy LSP per-flow rewrite information";
      leaf default-forward-class {
        type uint8;
        description "Default forward class";
      }

      leaf-list ifhandle {
        type uint32;
        max-elements 8;
        description
          "Ifhandle of per-destination policy at
         forward-class";
      }
    }  // grouping XTC-PFP-RW-INFO-BAG

    grouping XTC-PM-LD-LSP-SESSION-INFO {
      description
        "XTC PM LD LSP SESSION INFO";
      container bring-up-timer {
        description
          "Bring up timer information";
        uses CMN-TIMER-INFO;
      }  // container bring-up-timer

      leaf last-liveness-state-change-time {
        type uint64;
        description
          "Time when the last liveness state change
         occurred";
      }

      leaf last-liveness-state-change-age {
        type uint64;
        description
          "Age when the last liveness state change occurred";
      }

      leaf liveness-session-state {
        type Xtc-pm-live-session-state;
        description
          "Last liveness state change";
      }
    }  // grouping XTC-PM-LD-LSP-SESSION-INFO

    grouping XTC-PM-DM-METRICS {
      description "XTC PM DM METRICS";
      leaf average-delay {
        type uint32;
        description "Average delay";
      }

      leaf minimum-delay {
        type uint32;
        description "Minimum delay";
      }

      leaf maximum-delay {
        type uint32;
        description "Maximum delay";
      }

      leaf delay-variance {
        type uint32;
        description "Delay variance";
      }

      leaf aflag-set {
        type boolean;
        description "A flag is set";
      }
    }  // grouping XTC-PM-DM-METRICS

    grouping XTC-PM-DM-LSP-SESSION-INFO {
      description
        "XTC PM DM LSP SESSION INFO";
      container delay-metrics {
        description
          "Last delay-measurement metrics";
        uses XTC-PM-DM-METRICS;
      }  // container delay-metrics

      leaf last-delay-change-time {
        type uint64;
        description
          "Time when the last delay change occurred";
      }

      leaf last-delay-change-age {
        type uint64;
        description
          "Age when the last delay change occurred";
      }

      leaf delay-session-is-created {
        type boolean;
        description
          "Is delay-measurement session created";
      }
    }  // grouping XTC-PM-DM-LSP-SESSION-INFO

    grouping XTC-PM-LSP-INFO {
      description "XTC PM LSP INFO";
      container pm-delay-measurement-info {
        description
          "Delay-measurement information";
        uses XTC-PM-DM-LSP-SESSION-INFO;
      }  // container pm-delay-measurement-info

      container pm-liveness-detection-info {
        description
          "Liveness-detection information";
        uses XTC-PM-LD-LSP-SESSION-INFO;
      }  // container pm-liveness-detection-info

      leaf pm-delay-measurement-enabled {
        type boolean;
        description
          "Is delay-measurement enabled";
      }

      leaf pm-liveness-detection-enabled {
        type boolean;
        description
          "Is liveness-detection enabled";
      }
    }  // grouping XTC-PM-LSP-INFO

    grouping XTC-BFD-LSP-INFO {
      description "XTC BFD LSP INFO";
      container session-params {
        description
          "BFD session parameters that are to be used for
         this LSP";
        uses XTC-BFD-SESSION-PARAMS;
      }  // container session-params

      leaf last-session-state-change-time {
        type uint64;
        description
          "Time when the last BFD state change occurred";
      }

      leaf last-session-state-change-age {
        type uint64;
        description
          "Age when the last BFD state change occurred";
      }

      leaf session-state {
        type Xtc-bfd-session-state;
        description
          "State of the BFD session";
      }

      leaf is-created {
        type boolean;
        description "Is BFD session created";
      }

      leaf is-update-needed {
        type boolean;
        description
          "Is update needed to BFD";
      }

      leaf is-stale {
        type boolean;
        description
          "Is the BFD session stale";
      }
    }  // grouping XTC-BFD-LSP-INFO

    grouping XTC-POLICY-LSP-BAG {
      description "XTC Policy LSP";
      container binding-sid {
        description
          "Binding SID information";
        uses XTC-POLICY-BSID-BAG;
      }  // container binding-sid

      container install-timer {
        description
          "Install timer information";
        uses CMN-TIMER-INFO;
      }  // container install-timer

      container cleanup-timer {
        description
          "Cleanup timer information";
        uses CMN-TIMER-INFO;
      }  // container cleanup-timer

      container bfd-information {
        description "BFD information";
        uses XTC-BFD-LSP-INFO;
      }  // container bfd-information

      container performance-measurement-configuration {
        description
          "Performance-measurement configuration";
        uses XTC-PM-CPATH-CFG-INFO;
      }  // container performance-measurement-configuration

      container performance-measurement-info {
        description
          "Performance-measurement information";
        uses XTC-PM-LSP-INFO;
      }  // container performance-measurement-info

      container per-flow-rewrite-info {
        description
          "Per-flow LSP rewrite information";
        uses XTC-PFP-RW-INFO-BAG;
      }  // container per-flow-rewrite-info

      leaf lsp-id {
        type uint16;
        description "LSP ID";
      }

      leaf policy-id {
        type uint16;
        description "Policy ID";
      }

      leaf local-label {
        type uint32;
        description "Local label of the LSP";
      }

      leaf state {
        type Xtc-policy-lsp-sm-state;
        description "Current LSP state";
      }

      leaf is-active-lsp {
        type boolean;
        description
          "Whether this is the active LSP";
      }

      leaf is-reoptimized-lsp {
        type boolean;
        description
          "Whether this is the reoptimized LSP";
      }
    }  // grouping XTC-POLICY-LSP-BAG

    grouping XTC-SRV6-CONFIG-BAG {
      description
        "XTC SRv6 policy Configuration";
      container binding-sid {
        description "SRv6 Binding SID";
        uses XTC-PREFIX-SID-TYPE;
      }  // container binding-sid

      leaf locator-name {
        type string;
        description "Locator name";
      }

      leaf binding-sid-behavior {
        type uint32;
        description "Binding SID behavior";
      }
    }  // grouping XTC-SRV6-CONFIG-BAG

    grouping XTC-FWDING-STATS-BAG {
      description "Forwarding stats";
      leaf packets {
        type uint64;
        description
          "Number of packets forwarded";
      }

      leaf bytes {
        type uint64;
        units "byte";
        description
          "Number of bytes forwarded";
      }
    }  // grouping XTC-FWDING-STATS-BAG

    grouping XTC-PER-FLOW-PDP-ENTRY-BAG {
      description
        "XTC per-flow entry for per-destination policy";
      container stats {
        description
          "Forwarding stats of the per-destination policy";
        uses XTC-FWDING-STATS-BAG;
      }  // container stats

      leaf color {
        type uint32;
        description
          "Per-destination policy Color";
      }

      leaf state {
        type boolean;
        description
          "Per-destination policy state";
      }

      leaf forward-class {
        type uint8;
        description
          "Per-destination policy Forward Class";
      }
    }  // grouping XTC-PER-FLOW-PDP-ENTRY-BAG

    grouping XTC-PFP-CONFIG-BAG {
      description
        "XTC Per-flow policy Configuration";
      leaf default-forward-class {
        type uint8;
        description "Default forward class";
      }

      list pdp-entry {
        max-elements 8;
        description
          "Per-flow PDP entry table";
        uses XTC-PER-FLOW-PDP-ENTRY-BAG;
      }  // list pdp-entry
    }  // grouping XTC-PFP-CONFIG-BAG

    grouping XTC-PM-DM-STATS {
      description "XTC PM DM STATS";
      leaf session-create-counter {
        type uint64;
        description
          "Counters for session create";
      }

      leaf session-update-counter {
        type uint64;
        description
          "Counters of sessions updated";
      }

      leaf session-delete-counter {
        type uint64;
        description
          "Counters for session delete update";
      }

      leaf session-up-counter {
        type uint64;
        description
          "Counters for session up update";
      }

      leaf session-down-counter {
        type uint64;
        description
          "Counters for session down update";
      }

      leaf delay-notification-counter {
        type uint64;
        description
          "Counters for session delay notification";
      }

      leaf error-counter {
        type uint64;
        description
          "Counters for session error update";
      }
    }  // grouping XTC-PM-DM-STATS

    grouping XTC-PM-CPATH-INFO {
      description "XTC PM CPATH INFO";
      container liveness-session-statistics {
        description
          "Statistics of liveness sessions";
        uses XTC-PM-DM-STATS;
      }  // container liveness-session-statistics
    }  // grouping XTC-PM-CPATH-INFO

    grouping XTC-PM-LD-CFG-INFO {
      description "XTC PM LD CFG INFO";
      leaf invalidation-action {
        type Xtc-pm-live-invalidation-action;
        description
          "Action to be taken when the PM liveness session
         is invalidated";
      }

      leaf profile-name {
        type string;
        description "Profile name";
      }

      leaf logging-session-state-change {
        type boolean;
        description
          "Should syslog be emitted when session state
         changes";
      }
    }  // grouping XTC-PM-LD-CFG-INFO

    grouping XTC-PM-DM-CFG-INFO {
      description "XTC PM DM CFG INFO";
      leaf invalidation-action {
        type Xtc-pm-live-invalidation-action;
        description
          "Action to be taken when the PM liveness session
         is invalidated";
      }

      leaf profile-name {
        type string;
        description "Profile name";
      }

      leaf logging-delay-exceeded {
        type boolean;
        description
          "Should syslog be emitted when delay exceeds
         threshold";
      }
    }  // grouping XTC-PM-DM-CFG-INFO

    grouping XTC-PM-CPATH-CFG-INFO {
      description "XTC PM CPATH CFG INFO";
      container delay-measurement-configuration {
        description
          "Delay-measurement candidate-path configuration";
        uses XTC-PM-DM-CFG-INFO;
      }  // container delay-measurement-configuration

      container liveness-detection-configuration {
        description
          "Liveness-detection candidate-path configuration";
        uses XTC-PM-LD-CFG-INFO;
      }  // container liveness-detection-configuration

      leaf reverse-path-label {
        type uint32;
        description "Reverse-path label";
      }

      leaf delay-measurement-enabled {
        type boolean;
        description
          "Is delay-measurement enabled";
      }

      leaf liveness-detection-enabled {
        type boolean;
        description
          "Is delay-measurement enabled";
      }
    }  // grouping XTC-PM-CPATH-CFG-INFO

    grouping XTC-BFD-SESSION-STATS {
      description "XTC BFD SESSION STATS";
      leaf session-create {
        type uint64;
        description
          "Count of sessions created";
      }

      leaf session-update {
        type uint64;
        description
          "Count of sessions updated";
      }

      leaf session-delete {
        type uint64;
        description
          "Count of sessions destroyed";
      }

      leaf session-up {
        type uint64;
        description
          "Count of session state UP notifications";
      }

      leaf session-down {
        type uint64;
        description
          "Count of session state DOWN notifications";
      }

      leaf session-error {
        type uint64;
        description
          "Count of unexpected events or API errors";
      }
    }  // grouping XTC-BFD-SESSION-STATS

    grouping XTC-BFD-CPATH-INFO {
      description "XTC BFD CPATH INFO";
      container session-statistics {
        description
          "Candidate path session statistics";
        uses XTC-BFD-SESSION-STATS;
      }  // container session-statistics
    }  // grouping XTC-BFD-CPATH-INFO

    grouping XTC-BFD-SESSION-PARAMS {
      description "XTC BFD SESSION PARAMS";
      leaf minimum-interval {
        type uint32;
        description
          "Minimum interval between transmitted BFD packets";
      }

      leaf multiplier {
        type uint32;
        description
          "Number of missed packets before declaring
         session down";
      }

      leaf reverse-binding-label {
        type uint32;
        description "Reverse binding label";
      }
    }  // grouping XTC-BFD-SESSION-PARAMS

    grouping XTC-BFD-CFG-INFO-CPATH {
      description "XTC BFD CFG INFO CPATH";
      container session-params {
        description
          "BFD session parameters that should be used for
         LSPs created from this CPATH";
        uses XTC-BFD-SESSION-PARAMS;
      }  // container session-params

      leaf invalidation-action {
        type Xtc-bfd-invalidation-action;
        description
          "Action to be taken when BFD session is
         invalidated";
      }

      leaf submode-enable {
        type boolean;
        description "Is BFD configured";
      }

      leaf disable {
        type boolean;
        description
          "Is BFD temporarily disabled";
      }

      leaf logging-session-state-change {
        type boolean;
        description
          "Should syslog be emitted when session state
         changes";
      }
    }  // grouping XTC-BFD-CFG-INFO-CPATH

    grouping XTC-PROFILE-KEY {
      description "XTC profile key bag";
      leaf id {
        type uint16;
        description
          "Numeric part of profile key";
      }

      leaf source-address {
        type inet:ipv4-address;
        description "Source IPv4 address";
      }
    }  // grouping XTC-PROFILE-KEY

    grouping XTC-PCC-INFO-BAG {
      description "XTC PCC info";
      container orphan-timer {
        description "Deprecated";
        uses CMN-TIMER-INFO;
      }  // container orphan-timer

      container state-timer {
        description
          "State timer for PCE-initiated candidate paths in
         orphan state";
        uses CMN-TIMER-INFO;
      }  // container state-timer

      container fallback-timer {
        description
          "Timer for delaying delegation revoke back to LSP
         originator";
        uses CMN-TIMER-INFO;
      }  // container fallback-timer

      leaf symbolic-name {
        type string;
        description
          "Symbolic name of the PLSP";
      }

      leaf plsp-id {
        type uint32;
        description
          "PLSP-ID associated with the PCC info";
      }

      leaf is-orphan {
        type boolean;
        description
          "Whether the candidate path is in orphan state";
      }

      list profile-key {
        description "List of profile keys";
        uses XTC-PROFILE-KEY;
      }  // list profile-key
    }  // grouping XTC-PCC-INFO-BAG

    grouping CMN-TIMER-INFO {
      description "Timer information";
      leaf running {
        type boolean;
        description
          "Whether the timer is running";
      }

      leaf remaining-seconds {
        type int64;
        units "second";
        description
          "Number of remaining seconds";
      }

      leaf remaining-nano-seconds {
        type int64;
        units "nanosecond";
        description
          "Number of remaining nanoseconds";
      }
    }  // grouping CMN-TIMER-INFO

    grouping XTC-SEGMENTS-BAG {
      description "XTC SEGMENTS BAG";
      leaf segment-algorithm {
        type uint8;
        description "Segment Algorithm";
      }

      leaf protection-type {
        type Xtc-path-protection;
        description "Protection Type";
      }
    }  // grouping XTC-SEGMENTS-BAG

    grouping XTC-PATH-METRICS-BAG {
      description "SR path metrics bag";
      leaf margin-relative {
        type uint32;
        description "Margin Relative";
      }

      leaf margin-absolute {
        type uint32;
        description "Margin Absolute";
      }

      leaf maximum-segments {
        type uint16;
        description
          "Maximum number of segments";
      }

      leaf igp-metric-bound {
        type uint32;
        description "IGP Metric Bound";
      }

      leaf te-metric-bound {
        type uint32;
        description "TE Metric Bound";
      }

      leaf delay-metric-bound {
        type uint32;
        description "Delay Metric Bound";
      }

      leaf hop-count-metric-bound {
        type uint32;
        description "Hopcount Metric Bound";
      }

      leaf config-anycast {
        type boolean;
        description "Config Anycast";
      }
    }  // grouping XTC-PATH-METRICS-BAG

    grouping XTC-AFFINITY-COLOR {
      description "XTC AFFINITY COLOR";
      leaf color {
        type string;
        description "An affinity color";
      }
    }  // grouping XTC-AFFINITY-COLOR

    grouping XTC-AFFINITY-CONSTRAINT {
      description "XTC AFFINITY CONSTRAINT";
      leaf type {
        type uint8;
        description "Affinity type";
      }

      leaf value {
        type uint32;
        description "Affinity value";
      }

      leaf-list extended-value {
        type uint32;
        description
          "Extended Affinity values";
      }

      list color {
        description "Colors";
        uses XTC-AFFINITY-COLOR;
      }  // list color
    }  // grouping XTC-AFFINITY-CONSTRAINT

    grouping XTC-PATH-CONSTRAINTS-BAG {
      description
        "XTC SR per candidate path metrics information";
      container path-metrics {
        description "Path metrics";
        uses XTC-PATH-METRICS-BAG;
      }  // container path-metrics

      container segments {
        description "Segments constraints";
        uses XTC-SEGMENTS-BAG;
      }  // container segments

      list affinity-constraint {
        description
          "Affinity constraints list";
        uses XTC-AFFINITY-CONSTRAINT;
      }  // list affinity-constraint
    }  // grouping XTC-PATH-CONSTRAINTS-BAG

    grouping SRV6-SID-STRUCTURE-BAG {
      description "SRv6 MicroSID Structure";
      leaf locator-block-length {
        type uint8;
        description "Block Length";
      }

      leaf locator-node-length {
        type uint8;
        description "Node Length";
      }

      leaf function-length {
        type uint8;
        description "Function Length";
      }

      leaf argument-length {
        type uint8;
        description "Argument Length";
      }
    }  // grouping SRV6-SID-STRUCTURE-BAG

    grouping XTC-SR-HOP-TYPE {
      description "XTC SR hop";
      container sid {
        description "SID value";
        uses XTC-PREFIX-SID-TYPE;
      }  // container sid

      container local-address {
        description "Local address";
        uses XTC-IP-ADDR-TYPE;
      }  // container local-address

      container remote-address {
        description "Remote address";
        uses XTC-IP-ADDR-TYPE;
      }  // container remote-address

      container segment-id-structure {
        description
          "The SRv6 strucutre of the SID";
        uses SRV6-SID-STRUCTURE-BAG;
      }  // container segment-id-structure

      leaf sid-type {
        type Xtc-sr-sid;
        description "SID type";
      }

      leaf local-interface-index {
        type uint32;
        description
          "SNMP index of the upstream interface of this hop";
      }

      leaf remote-interface-index {
        type uint32;
        description
          "SNMP index of the downstream interface of this
         hop";
      }

      leaf algorithm {
        type uint8;
        description "Algorithm";
      }

      leaf sid-behavior {
        type uint16;
        description "Endpoint SID behavior";
      }
    }  // grouping XTC-SR-HOP-TYPE

    grouping XTC-POLICY-SL-BAG {
      description
        "XTC policy segment list information bag";
      container pce-address-af {
        description
          "IPv4 or IPv6 Address of the PCE that computed
         this path";
        uses XTC-IP-ADDR-TYPE;
      }  // container pce-address-af

      leaf name {
        type string;
        description
          "Explicit segment list name";
      }

      leaf type {
        type Xtc-policy-path;
        description "Segment list type";
      }

      leaf active {
        type boolean;
        description
          "Whether the segment list is active (used)";
      }

      leaf weight {
        type uint32;
        description
          "Weight of the segment list";
      }

      leaf metric-type {
        type uint8;
        description
          "Metric type of the segment list";
      }

      leaf metric-value {
        type uint64;
        description
          "Accumulated metric of the segment list";
      }

      leaf is-valid {
        type boolean;
        description "True if path is valid";
      }

      leaf pce-based-path {
        type boolean;
        description
          "True if the path is to be computed by PCE";
      }

      leaf pce-address {
        type inet:ipv4-address;
        description
          "Deprecated: IPv4 Address of the PCE that
         computed this path.           Use the PCE Addr
         AF field instead";
      }

      leaf error {
        type string;
        description
          "Error (for display only)";
      }

      leaf cumulative-te-metric {
        type uint32;
        description
          "The cumulative TE metric of the path";
      }

      leaf cumulative-igp-metric {
        type uint32;
        description
          "The cumulative IGP metric of the path";
      }

      leaf cumulative-latency {
        type uint32;
        description
          "The cumulative latency of the path";
      }

      leaf hop-count {
        type uint32;
        description
          "The number of hops in the path";
      }

      leaf kshortest-paths-computed {
        type uint32;
        description
          "Number of computed shortest paths before finding
         the one            that satisfies the
         constraints";
      }

      list hops {
        description "SR hop list";
        uses XTC-SR-HOP-TYPE;
      }  // list hops
    }  // grouping XTC-POLICY-SL-BAG

    grouping XTC-POLICY-CPATH-ORIGINATOR-BAG {
      description
        "XTC POLICY CPATH ORIGINATOR BAG";
      container node-address {
        description
          "Originator node address";
        uses XTC-IP-ADDR-TYPE;
      }  // container node-address

      leaf autonomous-system-number {
        type uint32;
        description
          "Originator Autonomous System Number";
      }
    }  // grouping XTC-POLICY-CPATH-ORIGINATOR-BAG

    grouping XTC-POLICY-CPATH-BAG {
      description
        "XTC policy candidate path bag";
      container originator {
        description
          "Candidate path originator";
        uses XTC-POLICY-CPATH-ORIGINATOR-BAG;
      }  // container originator

      container sr-path-constraints {
        description
          "SR candidate path constraints";
        uses XTC-PATH-CONSTRAINTS-BAG;
      }  // container sr-path-constraints

      container requested-bsid {
        description "Requested binding SID";
        uses XTC-PREFIX-SID-TYPE;
      }  // container requested-bsid

      container cleanup-timer {
        description
          "Cleanup timer if the candidate path is in the
         process of being cleaned up";
        uses CMN-TIMER-INFO;
      }  // container cleanup-timer

      container pcc-information {
        description
          "PCC PCEP-related information";
        uses XTC-PCC-INFO-BAG;
      }  // container pcc-information

      container bfd-config {
        description "BFD configuration";
        uses XTC-BFD-CFG-INFO-CPATH;
      }  // container bfd-config

      container bfd-information {
        description "BFD information";
        uses XTC-BFD-CPATH-INFO;
      }  // container bfd-information

      container performance-measurement-configuration {
        description
          "Performance-measurement configuration";
        uses XTC-PM-CPATH-CFG-INFO;
      }  // container performance-measurement-configuration

      container performance-measurement-info {
        description
          "Performance-measurement session information";
        uses XTC-PM-CPATH-INFO;
      }  // container performance-measurement-info

      container per-flow-information {
        description
          "Per-flow policy candidate-path information";
        uses XTC-PFP-CONFIG-BAG;
      }  // container per-flow-information

      container srv6-information {
        description
          "SRv6 policy candidate-path information";
        uses XTC-SRV6-CONFIG-BAG;
      }  // container srv6-information

      leaf name {
        type string;
        description "Candidate path name";
      }

      leaf preference {
        type uint32;
        description
          "Candidate path preference";
      }

      leaf protocol-originator {
        type Xtc-policy-cpath-proto-origin;
        description
          "Candidate path protocol origin";
      }

      leaf discriminator {
        type uint32;
        description
          "Candidate path discriminator";
      }

      leaf is-active {
        type boolean;
        description
          "Whether this is the currently active candidate
         path";
      }

      leaf is-reoptimizing {
        type boolean;
        description
          "Whether this is the candidate path that the
         policy is reoptimizing to";
      }

      leaf shutdown {
        type boolean;
        description
          "If set, the candidate path is administratively
         shutdown";
      }

      leaf error {
        type string;
        description
          "Candidate path error (for display only)";
      }

      leaf pce-group-name {
        type string;
        description "PCE group name";
      }

      list segment-list {
        description
          "Segment lists of the candidate path";
        uses XTC-POLICY-SL-BAG;
      }  // list segment-list
    }  // grouping XTC-POLICY-CPATH-BAG

    grouping XTC-POLICY-BSID-BAG {
      description
        "XTC policy binding SID information";
      container value {
        description "Binding SID value";
        uses XTC-PREFIX-SID-TYPE;
      }  // container value

      leaf is-fallback-dynamic {
        type boolean;
        description
          "Whether the BSID is in fallback dynamic mode";
      }

      leaf is-within-srlb-range {
        type boolean;
        description
          "Whether the BSID is within SRLB range";
      }

      leaf is-within-pfp-range {
        type boolean;
        description
          "Whether the BSID is within PFP range";
      }
    }  // grouping XTC-POLICY-BSID-BAG

    grouping XTC-POLICY-BAG {
      description "XTC policy information";
      container destination-address {
        description "Destination address";
        uses XTC-IP-ADDR-TYPE;
      }  // container destination-address

      container binding-sid {
        description
          "Binding SID information";
        uses XTC-POLICY-BSID-BAG;
      }  // container binding-sid

      container per-flow {
        description
          "Per-flow policy information";
        uses XTC-PER-FLOW-POLICY-BAG;
      }  // container per-flow

      container last-notify {
        description
          "Last notification to clients";
        uses XTC-POLICY-NOTIFY-BAG;
      }  // container last-notify

      leaf policy-name {
        type string;
        description "Policy name";
      }

      leaf administrative-up {
        type uint32;
        description "Admin up";
      }

      leaf operational-up {
        type uint32;
        description "Operational up";
      }

      leaf color {
        type uint32;
        description "Color";
      }

      leaf transition-count {
        type uint32;
        description
          "Indicates number of up/down transitions";
      }

      leaf forward-class {
        type uint32;
        description
          "Forward class of the policy";
      }

      leaf up-time {
        type uint64;
        units "nanosecond";
        description
          "Policy up time in nano seconds";
      }

      leaf up-age {
        type uint64;
        units "nanosecond";
        description
          "Policy up age (since) in nano seconds";
      }

      leaf down-time {
        type uint64;
        units "nanosecond";
        description
          "Policy down time in nano seconds";
      }

      leaf down-age {
        type uint64;
        units "nanosecond";
        description
          "Policy down age (since) in nano seconds";
      }

      leaf steering-bgp-disabled {
        type boolean;
        description
          "Whether steering to BGP client is disabled";
      }

      leaf steering-labeled-services-disabled {
        type boolean;
        description
          "Whether steering for labeled-services is
         disabled";
      }

      leaf invalidation-drop-enabled {
        type boolean;
        description
          "Whether invalidation drop is enabled";
      }

      leaf invalidated-traffic-dropping {
        type boolean;
        description
          "TRUE if the traffic on this policy is being
         dropped due to path invalidation";
      }

      leaf interface-handle {
        type uint32;
        description "Interface handle";
      }

      leaf profile-id {
        type uint16;
        description
          "deprecated - replaced by key list in
         xtc_pcc_info_bag";
      }

      leaf ipv6-caps-enabled {
        type boolean;
        description "IPv6 caps enabled";
      }

      list candidate-path {
        description "Candidate paths";
        uses XTC-POLICY-CPATH-BAG;
      }  // list candidate-path

      list ls-ps {
        description "LSPs";
        uses XTC-POLICY-LSP-BAG;
      }  // list ls-ps
    }  // grouping XTC-POLICY-BAG

    grouping XTC-GLOBAL-INFO-AD-BAG {
      description
        "XTC global admin distance information";
      leaf metric-type {
        type Cmn-metric;
        description "Metric type";
      }

      leaf admin-distance {
        type uint32;
        description "Admin distance";
      }
    }  // grouping XTC-GLOBAL-INFO-AD-BAG

    grouping XTC-GLOBAL-INFO-BAG {
      description "XTC global information";
      list admin-distance {
        description
          "List of global admin distances";
        uses XTC-GLOBAL-INFO-AD-BAG;
      }  // list admin-distance
    }  // grouping XTC-GLOBAL-INFO-BAG

    grouping XTC-IP-ADDR-TYPE {
      description "XTC IP ADDR TYPE";
      leaf af-name {
        type Xtc-af-id;
        description "AFName";
      }

      leaf ipv4 {
        when "../af-name = 'ipv4'" {
          description "../AFName = 'IPv4'";
        }
        type Xtc-ipv4-address;
        description "IPv4 address type";
      }

      leaf ipv6 {
        when "../af-name = 'ipv6'" {
          description "../AFName = 'IPv6'";
        }
        type Xtc-ipv6-address;
        description "IPv6 address type";
      }
    }  // grouping XTC-IP-ADDR-TYPE
  }  // submodule Cisco-IOS-XR-infra-xtc-agent-oper-sub1