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

    yang-version 1;

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

    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

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

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR infra-xtc package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-04-22" {
      description
        "Added TE metric field for Flex-algo ASLA.
       2021-04-08
         Change protection type from integer to enum.
       2021-03-31
         Added new enumeration Api-peer-stats-info-oper. Changed type of type in API-PEER-STATS-INFO to use Api-peer-stats-info-oper. This is a non backward compatible change.
       2021-03-04
         Added MSD list per topology link. Added SRLB list per topology node.
       2021-01-29
         Updated SRv6 Endpoint function from int to enum.
       2020-09-16
         Adding operational nodes for new features path invalidation drop protected and unprotected path Operational nodes for PCE segment-routing traffic-eng policy
       2020-09-01
         Added uB6SID field in the LSP object
       2020-08-18
         Added SRv6 LSP details fields in the LSP object
       2020-07-13
         Added NodeID fields in the uN SID object in the IPv6 topology.
       2020-04-20
         Added fields in the PCE IPv6 link object.";
    }

    revision "2020-03-17" {
      description
        "Add flex-algo related operational nodes. Updated description of statistics-nodes. Add SR-PAG related operational nodes. Add PCE authentication related operational nodes.
       2020-02-03
       Added TCP AuthenticationOption related operational model. Implemented show pce authentication. Added classes AuthenticationKeyTable and AuthenticationKey.
       2019-11-07
       Adding leaf preference, leaf interface-name, and leaf profile-id to support a new HTTP API bindpoint for sibling PCEs.
       2019-10-09
       Adding enum sr-flex-algo-prefix-sid, enum pce-cspf-flex-algo-definition-mistmatch, leaf flex-algo-prefix-sids, list sr-flex-algo, and container flex-algos to support Flex-algo info.";
    }

    revision "2019-10-02" {
      description
        "Added REST peer statistic information.
       2019-09-27
       Implement new show pce lsp and show pce initiated tunnels commands for Optima";
    }

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

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

    revision "2017-08-24" {
      description
        "Added C flag to pcep flags.";
    }

    revision "2017-06-26" {
      description
        "Change identifiers to be more readable.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

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

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

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

    typedef Nbapi-peer-state {
      type enumeration {
        enum "api-peer-state-down" {
          value 0;
          description
            "Operational status down";
        }
        enum "api-peer-state-up" {
          value 1;
          description
            "Operational status up";
        }
      }
      description "Nbapi peer state";
    }

    typedef Api-peer-stats-info-oper {
      type enumeration {
        enum "api-operation-invalid" {
          value 0;
          description "Invalid operation";
        }
        enum "api-operation-lsp-create" {
          value 1;
          description "LSP create";
        }
        enum
          "api-operation-lsp-reclaim-delegation" {
          value 2;
          description
            "LSP reclaim delegation";
        }
        enum
          "api-operation-lsp-drop-delegation" {
          value 3;
          description "LSP drop delegation";
        }
        enum "api-operation-lsp-update" {
          value 4;
          description "LSP update";
        }
        enum "api-operation-lsp-delete" {
          value 5;
          description "LSP delete";
        }
        enum "api-operation-lsp-delete-all" {
          value 6;
          description "LSP delete all";
        }
        enum "api-operation-lsp-computation" {
          value 7;
          description "LSP compute";
        }
        enum
          "api-operation-lsp-subscription" {
          value 8;
          description "LSP subscrube";
        }
        enum
          "api-operation-topology-subscription" {
          value 9;
          description "Topology subscribe";
        }
        enum
          "api-operation-topology-subscriptionv2" {
          value 10;
          description
            "Topology subscribe version 2";
        }
        enum
          "api-operation-peer-subscription" {
          value 11;
          description "Peer subscribe";
        }
        enum
          "api-operation-bwod-subscription" {
          value 12;
          description "BWoD subscribe";
        }
        enum "api-operation-p2mp-install" {
          value 13;
          description "P2MP install";
        }
        enum "api-operation-p2mp-delete" {
          value 14;
          description "P2MP delete";
        }
        enum "api-operation-p2mp-delete-all" {
          value 15;
          description "P2MP delete all";
        }
        enum
          "api-operation-p2mp-reoptimization" {
          value 16;
          description "P2MP reoptimization";
        }
        enum
          "api-operation-p2mp-get-information" {
          value 17;
          description "P2MP get information";
        }
        enum "api-operation-external-lsp" {
          value 18;
          description "External LSP";
        }
        enum
          "api-operation-topology-link-attribute" {
          value 19;
          description
            "Topology link attribute update";
        }
        enum "api-operationversion" {
          value 20;
          description "API version";
        }
        enum "api-operation-maximum" {
          value 21;
          description "Maximum value";
        }
      }
      description "Api peer stats info oper";
    }

    typedef Pce-headend-swap {
      type enumeration {
        enum "pcehs-none" {
          value 0;
          description "Headends not swapped";
        }
        enum "pcehs-plain" {
          value 1;
          description "Headends swapped";
        }
        enum "pcehs-rwi" {
          value 2;
          description
            "Headends swapped with increment";
        }
      }
      description "PCE Headends Swap Code";
    }

    typedef Path-work-node {
      type enumeration {
        enum "path-work-bag-node-type-work" {
          value 0;
          description "work";
        }
        enum
          "path-work-bag-node-type-worker-prio-1" {
          value 1;
          description
            "reoptimization worker";
        }
        enum
          "path-work-bag-node-type-region" {
          value 2;
          description "region";
        }
      }
      description "Path work node type";
    }

    typedef Pce-treesid-state {
      type enumeration {
        enum "none" {
          value 0;
          description "No state";
        }
        enum "programming" {
          value 1;
          description
            "Programming non-root nodes";
        }
        enum "programming-root" {
          value 2;
          description
            "Programming the root node";
        }
        enum "pruning" {
          value 3;
          description
            "Pruning stale legs on non-root nodes";
        }
        enum "pruning-root" {
          value 4;
          description
            "Pruning stale legs on root node";
        }
        enum "deleting" {
          value 5;
          description
            "TreeSID is being deleted";
        }
      }
      description "Pce treesid state";
    }

    typedef Pce-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 "Bud Node";
        }
      }
      description "Pce treesid role";
    }

    typedef Pce-cspf-rc {
      type enumeration {
        enum "pce-cspf-not-set" {
          value 0;
          description "Not set";
        }
        enum "pce-cspf-src-not-found" {
          value 1;
          description "Source not found";
        }
        enum "pce-cspf-dst-not-found" {
          value 2;
          description
            "Destination not found";
        }
        enum "pce-cspf-second-src-not-found" {
          value 3;
          description
            "Second source not found";
        }
        enum "pce-cspf-second-dst-not-found" {
          value 4;
          description
            "Second destination not found";
        }
        enum "pce-cspf-no-mem" {
          value 5;
          description "No memory";
        }
        enum "pce-cspf-ex-path-not-resolved" {
          value 6;
          description
            "Second path not resolved";
        }
        enum "pce-cspf-no-path" {
          value 7;
          description "No path";
        }
        enum "pce-cspf-sp-success" {
          value 8;
          description
            "Shortest path success";
        }
        enum "pce-cspf-error" {
          value 9;
          description "Error";
        }
        enum
          "pce-cspf-fallback-srlg-node-node" {
          value 10;
          description
            "Fallback from SRLG-NODE to NODE";
        }
        enum
          "pce-cspf-fallback-srlg-node-link" {
          value 11;
          description
            "Fallback from SRLG-NODE to LINK";
        }
        enum
          "pce-cspf-fallback-srlg-node-sp" {
          value 12;
          description
            "Fallback from SRLG-NODE to SP";
        }
        enum "pce-cspf-fallback-node-link" {
          value 13;
          description
            "Fallback from NODE to LINK";
        }
        enum "pce-cspf-fallback-link-sp" {
          value 14;
          description
            "Fallback from LINK to SP";
        }
        enum "pce-cspf-fallback-node-sp" {
          value 15;
          description
            "Fallback from NODE to SP";
        }
        enum "pce-cspf-fallback-srlg-link" {
          value 16;
          description
            "Fallback from SRLG to LINK";
        }
        enum "pce-cspf-fallback-srlg-sp" {
          value 17;
          description
            "Fallback from SRLG to SP";
        }
        enum "pce-cspf-dp-success" {
          value 18;
          description
            "Disjoint path success";
        }
        enum
          "pce-cspf-flex-algo-definition-mistmatch" {
          value 19;
          description
            "Flex-algo definition mistmatch across IGP
           domain";
        }
        enum
          "pce-cspf-latency-bound-exceeded" {
          value 20;
          description
            "Latency bound exceeded for computed path";
        }
      }
      description "PCE CSPF Result Code";
    }

    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 Topo-msd-subtype {
      type enumeration {
        enum "msd-type-mpls" {
          value 1;
          description
            "Base MPLS Imposition MSD";
        }
        enum "msd-type-erld" {
          value 2;
          description "ERLD MSD";
        }
        enum "msd-type-srh-max-sl" {
          value 41;
          description "SRH Max SL";
        }
        enum "msd-type-srh-max-end-pop" {
          value 42;
          description "SRH Max End Pop";
        }
        enum "msd-type-srh-max-h-encaps" {
          value 44;
          description "SRH Max H.encaps";
        }
        enum "msd-type-srh-max-end-d" {
          value 45;
          description "SRH Max End D";
        }
        enum "msd-type-unknown" {
          value 255;
          description "Unknown";
        }
      }
      description "Topo msd subtype";
    }

    typedef Sid {
      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 "SID Types";
    }

    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 Pce-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 Cmn-auth {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "md5-clear" {
          value 1;
          description "MD5 Clear";
        }
        enum "md5-encrypted" {
          value 2;
          description "MD5 Encrypted";
        }
        enum "authentication-option" {
          value 3;
          description
            "Authentication Option";
        }
        enum "authentication-keychain" {
          value 4;
          description
            "Authentication Keychain";
        }
        enum "max" {
          value 5;
          description "Max";
        }
      }
      description "Cmn auth";
    }

    typedef Pcep-state {
      type enumeration {
        enum "tcp-close" {
          value 0;
          description "TCP close";
        }
        enum "tcp-listen" {
          value 1;
          description "TCP listen";
        }
        enum "tcp-connect" {
          value 2;
          description "TCP connect";
        }
        enum "pcep-closed" {
          value 3;
          description "PCEP closed";
        }
        enum "pcep-opening" {
          value 4;
          description "PCEP opening";
        }
        enum "pcep-open" {
          value 5;
          description "PCEP open";
        }
      }
      description "PCEP State";
    }

    typedef Pce-proto {
      type enumeration {
        enum "pcep" {
          value 0;
          description "PCE protocol";
        }
        enum "netconf" {
          value 1;
          description "Netconf protocol";
        }
      }
      description "PCE peer protocol";
    }

    typedef Xtc-ipv6-address {
      type inet:ipv6-address;
      description "Xtc ipv6 address";
    }

    typedef Xtc-ipv4-address {
      type inet:ipv4-address;
      description "Xtc ipv4 address";
    }

    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";
    }

    typedef Pce-rro {
      type enumeration {
        enum "rro-type-ipv4-address" {
          value 0;
          description "IPv4 Address";
        }
        enum "rro-type-mpls-label" {
          value 1;
          description "MPLS Label";
        }
        enum "rro-type-sripv4-node-sid" {
          value 2;
          description
            "Segment Routing IPv4 Node SID";
        }
        enum "rro-type-sripv4-adjacency-sid" {
          value 3;
          description
            "Segment Routing IPv4 Adjacency SID";
        }
        enum "rro-type-sr-nai-null" {
          value 4;
          description
            "Segment Routing with NAI null";
        }
      }
      description "PCE RRO type";
    }

    typedef Pce-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 "ipv6-node-sid" {
          value 2;
          description "IPv6 Node SID";
        }
        enum "ipv6-adjacency-sid" {
          value 3;
          description "IPv6 Adjacency SID";
        }
        enum "ipv4-unnumbered-adjacency-sid" {
          value 4;
          description
            "IPv4 unnumbered adjacency segment identifier";
        }
        enum "ipv6-linklocal-adjacency-sid" {
          value 5;
          description
            "IPv6 linklocal adjacency segment identifier";
        }
        enum "unknown-sid" {
          value 6;
          description "Unknown SID";
        }
      }
      description "PCE SR SID type";
    }

    typedef Lsp-state {
      type enumeration {
        enum "lsp-down" {
          value 0;
          description "LSP is down";
        }
        enum "lsp-up" {
          value 1;
          description "LSP is up";
        }
      }
      description "LSP setup type";
    }

    typedef Pcep-lsp-state {
      type enumeration {
        enum "lsp-down" {
          value 0;
          description "LSP is down";
        }
        enum "lsp-up" {
          value 1;
          description "LSP is up";
        }
        enum "lsp-active" {
          value 2;
          description
            "LSP is active (carrying traffic)";
        }
        enum "lsp-going-down" {
          value 3;
          description "LSP is going down";
        }
        enum "lsp-being-signaled" {
          value 4;
          description
            "LSP is being signaled";
        }
      }
      description "PCEP operation protocol";
    }

    typedef Lsp-setup {
      type enumeration {
        enum "setup-rsvp" {
          value 0;
          description
            "LSP is established using RSVP-TE";
        }
        enum "setup-sr" {
          value 1;
          description
            "LSP is established using SR-TE";
        }
        enum "setup-unknown" {
          value 2;
          description
            "Unknown LSP establishment method";
        }
      }
      description "LSP setup 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 Pce-ipv6-address {
      type inet:ipv6-address;
      description "Pce ipv6 address";
    }

    typedef Pce-ipv4-address {
      type inet:ipv4-address;
      description "Pce ipv4 address";
    }

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

    grouping API-PEER-STATS-INFO {
      description "Stats info struct";
      leaf api-peer-type {
        type Api-peer-stats-info-oper;
        description "Peer operation types";
      }

      leaf peer-state {
        type Nbapi-peer-state;
        description "Peer state";
      }

      leaf id {
        type uint32;
        description
          "Unique Identifier for stats";
      }

      leaf failed-flag {
        type boolean;
        description "Indicates failure";
      }

      leaf start-time {
        type uint32;
        description "Indicates start time";
      }

      leaf last-seen-time {
        type uint32;
        description
          "Indicates Last seen time";
      }

      leaf queue-valid-time {
        type uint32;
        description
          "Timestamp, when something was sent from queue or
         when it was empty.";
      }

      leaf send-queue-size {
        type uint64;
        units "byte";
        description
          "Size of data in send queue in bytes";
      }

      leaf rest-query {
        type string;
        description "query string";
      }
    }  // grouping API-PEER-STATS-INFO

    grouping API-PEER-STATS-BAG {
      description "API PEER STATS BAG";
      container peer-address {
        description "Indicates the peer IP";
        uses PCE-IP-ADDR-TYPE;
      }  // container peer-address

      leaf uid {
        type uint32;
        description
          "Indicates the UID for the peer";
      }

      list stats {
        description "Stats info";
        uses API-PEER-STATS-INFO;
      }  // list stats
    }  // grouping API-PEER-STATS-BAG

    grouping PCE-PATH-LIST-BAG {
      description "PCE path list";
      leaf headends-swapped {
        type Pce-headend-swap;
        description "Headends swapped";
      }

      leaf cspf-result {
        type Pce-cspf-rc;
        description "CSPF Result";
      }

      leaf iterations-done {
        type uint32;
        description
          "Iterations of the Suurballe-Tarjan algorithm";
      }

      list output-path {
        description "Output PCE paths";
        uses PCE-PATH-BAG;
      }  // list output-path
    }  // grouping PCE-PATH-LIST-BAG

    grouping PCE-SRV6-HOP-BAG {
      description "SRv6 Hop Details";
      container srv6sid {
        description "SRv6 SID detailed";
        uses SRV6-SID-BAG;
      }  // container srv6sid

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

      leaf remote-ipv6-address {
        type inet:ipv6-address;
        description "Remote IPv6 address";
      }
    }  // grouping PCE-SRV6-HOP-BAG

    grouping PCE-ADDR-BAG {
      description "PCE Address Information";
      container srv6-hop {
        description "SRv6 Hop information";
        uses PCE-SRV6-HOP-BAG;
      }  // container srv6-hop

      leaf address-family {
        type uint8;
        description "Address Family";
      }

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

      leaf ipv6-prefix {
        type inet:ipv6-address;
        description "IPv6 prefix";
      }
    }  // grouping PCE-ADDR-BAG

    grouping PCE-PATH-BAG {
      description "PCE path information";
      container source-xr {
        description "Source of path";
        uses PCE-IP-ADDR-TYPE;
      }  // container source-xr

      container destination-xr {
        description "Destination of path";
        uses PCE-IP-ADDR-TYPE;
      }  // container destination-xr

      leaf cost {
        type uint64;
        description "Cost";
      }

      list hops {
        description "Hop addresses";
        uses PCE-ADDR-BAG;
      }  // list hops
    }  // grouping PCE-PATH-BAG

    grouping PATH-WORK-CACHE-STATS {
      description
        "Statistics about a particular cache";
      leaf work-consumed {
        type uint64;
        description
          "Number of work nodes consumed";
      }

      leaf cache-hit {
        type uint64;
        description
          "How many times we were able to use the cache";
      }

      leaf cache-miss {
        type uint64;
        description
          "How many times we had to recompute the cache";
      }

      leaf cache-miss-time-usec {
        type uint64;
        units "microsecond";
        description
          "How many microseconds the last computation took";
      }

      leaf average-cache-miss-time-usec {
        type uint64;
        units "microsecond";
        description
          "How many microseconds the average computation
         took";
      }

      leaf error {
        type uint64;
        description "Number of errors";
      }

      leaf run-time-usec {
        type uint64;
        units "microsecond";
        description
          "How many microseconds it took to verify one
         region";
      }
    }  // grouping PATH-WORK-CACHE-STATS

    grouping PATH-WORK-GROUP-STATS {
      description "Path work group stats";
      list last {
        description
          "Last several computations";
        uses PATH-WORK-CACHE-STATS;
      }  // list last
    }  // grouping PATH-WORK-GROUP-STATS

    grouping PATH-WORK-REGION {
      description "Path work region";
      leaf work-count {
        type uint32;
        description
          "Number of work elements";
      }
    }  // grouping PATH-WORK-REGION

    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 PATH-WORK-GROUP-KEY {
      description
        "Identifies path work group";
      container source-address {
        description "Source address";
        uses XTC-IP-ADDR-TYPE;
      }  // container source-address

      leaf maximum-segments {
        type uint16;
        description
          "Max number of segments to impose";
      }

      leaf metric-type {
        type uint8;
        description
          "Metric type being optimized";
      }

      leaf non-ocspf {
        type boolean;
        description
          "Constraints are something other than O-CSPF";
      }

      list affinity-constraint {
        description
          "Affinity constraints list";
        uses XTC-AFFINITY-CONSTRAINT;
      }  // list affinity-constraint
    }  // grouping PATH-WORK-GROUP-KEY

    grouping PATH-WORK-GROUP {
      description "Path work group";
      container key {
        description
          "Unique key to identify group";
        uses PATH-WORK-GROUP-KEY;
      }  // container key

      container region-1 {
        description
          "First region of the group";
        uses PATH-WORK-REGION;
      }  // container region-1

      container region-2 {
        description
          "Second region of the group";
        uses PATH-WORK-REGION;
      }  // container region-2

      container stats {
        description "Group statistics";
        uses PATH-WORK-GROUP-STATS;
      }  // container stats

      leaf works-count {
        type uint64;
        description
          "Number of works in this group";
      }

      leaf worker-past-region1 {
        type boolean;
        description
          "Is the worker past region_1";
      }
    }  // grouping PATH-WORK-GROUP

    grouping PCE-ASSO-LSP-INFO {
      description
        "Association LSP common information";
      container pcc-address {
        description "PCC address";
        uses PCE-IP-ADDR-TYPE;
      }  // container pcc-address

      leaf tunnel-id {
        type uint32;
        description "Tunnel ID";
      }

      leaf lspid {
        type uint32;
        description "LSP ID";
      }

      leaf tunnel-name {
        type string;
        description "Tunnel Name";
      }

      leaf pce-based {
        type boolean;
        description "PCE Based";
      }

      leaf plsp-id {
        type uint32;
        description "PLSP ID";
      }
    }  // grouping PCE-ASSO-LSP-INFO

    grouping PCE-ASSO-BAG {
      description
        "PCE Association information";
      container association-source {
        description "Association Source";
        uses PCE-IP-ADDR-TYPE;
      }  // container association-source

      leaf association-type {
        type uint32;
        description "Association Type";
      }

      leaf association-id {
        type uint32;
        description "Association ID";
      }

      leaf strict {
        type boolean;
        description
          "Association Strict Mode";
      }

      leaf status {
        type uint32;
        description "Association Status";
      }

      leaf headends-swapped {
        type uint32;
        description "Headends Swapped";
      }

      list association-lsp {
        description "Association LSP Info";
        uses PCE-ASSO-LSP-INFO;
      }  // list association-lsp
    }  // grouping PCE-ASSO-BAG

    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 PATH-WORK-NODE {
      description "Path work node";
      leaf type {
        type Path-work-node;
        description "Node type";
      }

      leaf repr {
        type string;
        description "String representation";
      }
    }  // grouping PATH-WORK-NODE

    grouping PCE-NODE-FLEX-ALGO-DEFINITION {
      description
        "PCE Node Flex-algo definition";
      container node-id {
        description
          "Flex-algo Advertising Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

      container flex-algo-definition {
        description "Flex-algo definition";
        uses PCE-FA-DEFINITION;
      }  // container flex-algo-definition
    }  // grouping PCE-NODE-FLEX-ALGO-DEFINITION

    grouping PCE-IGP-AREA-INFO-TYPE {
      description "PCE IGP AREA INFO TYPE";
      leaf igp-id {
        type Pce-igp-info-id;
        description "IGP ID";
      }

      leaf level {
        when "../igp-id = 'isis'" {
          description "../IGP_ID = 'ISIS'";
        }
        type uint32;
        description "ISIS level";
      }

      leaf area {
        when "../igp-id = 'ospf'" {
          description "../IGP_ID = 'OSPF'";
        }
        type uint32;
        description "OSPF area";
      }
    }  // grouping PCE-IGP-AREA-INFO-TYPE

    grouping PCE-FLEX-ALGO-AREA {
      description
        "Flex-algo information per Area";
      container igp-area {
        description
          "IGP-area-specific information";
        uses PCE-IGP-AREA-INFO-TYPE;
      }  // container igp-area

      leaf igp-id {
        type Pce-igp-info-id;
        description "IGP type";
      }

      leaf domain-identifier {
        type uint64;
        description "Domain identifier";
      }

      list definition {
        description
          "Per Area Flex-Algo Definition";
        uses PCE-NODE-FLEX-ALGO-DEFINITION;
      }  // list definition
    }  // grouping PCE-FLEX-ALGO-AREA

    grouping PCE-PEER-PROTO-SUMMARY-BAG {
      description
        "Peer summary for specified protocol";
      leaf peer-count-up {
        type uint32;
        description
          "Number of peers in up state";
      }

      leaf peer-count-down {
        type uint32;
        description
          "Number of peers in down state";
      }

      leaf peer-count-all {
        type uint32;
        description "Number of all peers";
      }
    }  // grouping PCE-PEER-PROTO-SUMMARY-BAG

    grouping PCE-PEER-SUMMARY-BAG {
      description "Peer summary information";
      container pcep-peers {
        description
          "PCEP peers summary information";
        uses PCE-PEER-PROTO-SUMMARY-BAG;
      }  // container pcep-peers
    }  // grouping PCE-PEER-SUMMARY-BAG

    grouping PCE-TREESID-HOP-BAG {
      description "TreeSID hop information";
      leaf next-hop-address {
        type inet:ipv4-address;
        description
          "Next hop remote address";
      }

      leaf next-hop-label {
        type uint32;
        description
          "Next hop outgoing label";
      }

      leaf next-hop-node-address {
        type inet:ipv4-address;
        description "Next hop node address";
      }

      leaf next-hop-node-name {
        type string;
        description "Next hop node name";
      }

      leaf stale {
        type boolean;
        description
          "Stale hop; will be removed in next update";
      }

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

      leaf fast-reroute {
        type boolean;
        description
          "Fast Re-route to hop remote node";
      }
    }  // grouping PCE-TREESID-HOP-BAG

    grouping PCE-TREESID-NODE-BAG {
      description "TreeSID node information";
      leaf prefix-address {
        type inet:ipv4-address;
        description "Node prefix address";
      }

      leaf name {
        type string;
        description "Node name";
      }

      leaf role {
        type Pce-treesid-role;
        description "Node role";
      }

      leaf awaiting-report {
        type boolean;
        description "Awaiting report";
      }

      leaf stale {
        type boolean;
        description "Stale node";
      }

      list next-hop {
        description "Next hops";
        uses PCE-TREESID-HOP-BAG;
      }  // list next-hop
    }  // grouping PCE-TREESID-NODE-BAG

    grouping PCE-TREESID-BAG {
      description "TreeSID information";
      container attribute-info {
        description "TreeSID attributes";
        uses PCE-LSPA-INFO;
      }  // container attribute-info

      leaf name-xr {
        type string;
        description "Name of the TreeSID";
      }

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

      leaf error {
        type string;
        description
          "Last path computation error";
      }

      leaf label {
        type uint32;
        description "SID of the TreeSID";
      }

      leaf source-address {
        type inet:ipv4-address;
        description
          "Address of the source node";
      }

      leaf pcc-address {
        type inet:ipv4-address;
        description
          "PCC Address of the source node";
      }

      leaf operational-state {
        type boolean;
        description "Operational state";
      }

      leaf administrative-state {
        type boolean;
        description "Administrative state";
      }

      leaf lfa-protected {
        type boolean;
        description
          "LFA Protection enabled?";
      }

      leaf from-checkpoint {
        type boolean;
        description
          "Created from checkpoint database?";
      }

      leaf pcc-initiated {
        type boolean;
        description "Initiated by PCC?";
      }

      leaf state {
        type Pce-treesid-state;
        description
          "State of the TreeSID (ie, pending operation)";
      }

      leaf uptime {
        type uint32;
        units "second";
        description
          "Uptime of the tunnel in seconds";
      }

      leaf transition-count {
        type uint32;
        description
          "Number of transitions between operational
         up/down";
      }

      leaf tree-id-xr {
        type uint32;
        description "TreeSID Tree-ID";
      }

      leaf-list destination-address {
        type inet:ipv4-address;
        description
          "List of destination addresses";
      }

      list nodes {
        description
          "List of nodes associated with this TreeSID";
        uses PCE-TREESID-NODE-BAG;
      }  // list nodes

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

    grouping PCE-SIBLING-CONN-BAG {
      description
        "PCE sibling connection information";
      container address {
        description "Address of sibling";
        uses XTC-IP-ADDR-TYPE;
      }  // container address

      leaf connected {
        type boolean;
        description
          "Flag indicating the connection status";
      }

      leaf packet-read-size {
        type uint32;
        description "Input buffer data size";
      }

      leaf packet-write {
        type uint32;
        description
          "Packets in output buffer";
      }
    }  // grouping PCE-SIBLING-CONN-BAG

    grouping PCE-SYNCED-LSP-DISJOINTNESS-BAG {
      description "PCE disjointness bag";
      container association-information {
        description
          "Association information";
        uses PCE-ASSO-INFO;
      }  // container association-information

      leaf fallback {
        type boolean;
        description "Fallback flag";
      }
    }  // grouping PCE-SYNCED-LSP-DISJOINTNESS-BAG

    grouping PCE-AFFINITY-BAG {
      description "PCE affinity bag";
      leaf exclude-any {
        type uint32;
        description "Exclude any";
      }

      leaf include-any {
        type uint32;
        description "Include any";
      }

      leaf include-all {
        type uint32;
        description "Include all";
      }
    }  // grouping PCE-AFFINITY-BAG

    grouping PCE-SIBLING-SYNCED-LSP-BAG {
      description
        "PCE sibling synced LSP data";
      container actual-pcc-address {
        description
          "Actual address of PCC peer where the PCInitiate
         was sent";
        uses XTC-IP-ADDR-TYPE;
      }  // container actual-pcc-address

      container requested-pcc-address {
        description
          "Requested address of PCC peer used by the
         creator of LSP";
        uses XTC-IP-ADDR-TYPE;
      }  // container requested-pcc-address

      container affinity {
        description "Affinity";
        uses PCE-AFFINITY-BAG;
      }  // container affinity

      container disjointness {
        description "Disjointness";
        uses PCE-SYNCED-LSP-DISJOINTNESS-BAG;
      }  // container disjointness

      leaf lsp-name-xr {
        type string;
        description "Name of the LSP";
      }

      leaf remote-ls-pdata {
        type boolean;
        description
          "Flag to indicate whether this is remote lsp data
         or a local copy";
      }

      leaf protected {
        type boolean;
        description
          "Flag to indicate if protected path is required";
      }

      leaf allow-xtc-reoptimization {
        type boolean;
        description
          "Flag to indicate if reoptimization is allowed";
      }
    }  // grouping PCE-SIBLING-SYNCED-LSP-BAG

    grouping PCE-POLICY-CPATH-BAG {
      description
        "PCE policy candidate-path";
      leaf name {
        type string;
        description
          "Name of the candidate-path";
      }

      leaf plsp-id {
        type uint32;
        description
          "PLSP-ID pf tje candidate-path";
      }

      leaf active-flag {
        type boolean;
        description
          "Flag to mention if the candidate-path is
         currently active";
      }
    }  // grouping PCE-POLICY-CPATH-BAG

    grouping PCE-POLICY-BAG {
      description "PCE policy";
      container pcc-address-xr {
        description
          "Path computation client address";
        uses XTC-IP-ADDR-TYPE;
      }  // container pcc-address-xr

      container end-point {
        description
          "End-point of the policy";
        uses XTC-IP-ADDR-TYPE;
      }  // container end-point

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

      leaf color {
        type uint32;
        description "Color of the policy";
      }

      list candidate-path {
        description
          "Array of candidate-paths";
        uses PCE-POLICY-CPATH-BAG;
      }  // list candidate-path
    }  // grouping PCE-POLICY-BAG

    grouping PCE-SR-MPLS-PATH-BAG {
      description "PCE SR path information";
      container source {
        description "Source of path";
        uses PCE-IP-ADDR-TYPE;
      }  // container source

      container destination {
        description "Destination of path";
        uses PCE-IP-ADDR-TYPE;
      }  // container destination

      leaf cost {
        type uint64;
        description "Cost";
      }

      list hops {
        description "SR hops";
        uses PCE-SR-HOP-TYPE;
      }  // list hops
    }  // grouping PCE-SR-MPLS-PATH-BAG

    grouping PCE-SR-MPLS-PATH-LIST-BAG {
      description "PCE SR MPLS path list";
      leaf cspf-result {
        type Pce-cspf-rc;
        description
          "Result of the computation";
      }

      leaf iterations-done {
        type uint32;
        description
          "Iterations performed of the Suurballe-Tarjan
         algorithm";
      }

      list output-path {
        description "Output SR MPLS paths";
        uses PCE-SR-MPLS-PATH-BAG;
      }  // list output-path
    }  // grouping PCE-SR-MPLS-PATH-LIST-BAG

    grouping PCE-PEER-AUTH-OPTION-BAG {
      description
        "PCE Peer Authentication Option information";
      container peer-address {
        description "Peer address";
        uses PCE-IP-ADDR-TYPE;
      }  // container peer-address

      container authentication-option {
        description
          "Authentication Option information";
        uses PCE-AUTH-OPTION-BAG;
      }  // container authentication-option
    }  // grouping PCE-PEER-AUTH-OPTION-BAG

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

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

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

      list address {
        description "Prefix address";
        uses PCE-PFX-ENTRY;
      }  // list address
    }  // grouping PCE-PFX-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-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 pcep-allowed {
        type boolean;
        description
          "Whether PCEP is allowed";
      }

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

      leaf timer-value {
        type uint32;
        description
          "Topology ready timer value selected at start";
      }
    }  // grouping XTC-TOPO-READY-BAG

    grouping PCE-TOPO-STATS-BAG {
      description
        "Statistics on topology update";
      leaf num-nodes-added {
        type uint32;
        description "Number of nodes added";
      }

      leaf num-nodes-deleted {
        type uint32;
        description
          "Number of nodes deleted";
      }

      leaf num-links-added {
        type uint32;
        description "Number of links added";
      }

      leaf num-links-deleted {
        type uint32;
        description
          "Number of links deleted";
      }

      leaf num-prefixes-added {
        type uint32;
        description
          "Number of prefixes added";
      }

      leaf num-prefixes-deleted {
        type uint32;
        description
          "Number of prefixes deleted";
      }
    }  // grouping PCE-TOPO-STATS-BAG

    grouping PCE-NODE-SUMMARY-BAG {
      description
        "PCE Node Summary Information";
      container stats-topology-update {
        description
          "Statistics on topology update";
        uses PCE-TOPO-STATS-BAG;
      }  // container stats-topology-update

      container topology-ready-summary {
        description "Topology ready summary";
        uses XTC-TOPO-READY-BAG;
      }  // container topology-ready-summary

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

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

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

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

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

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

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

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

      leaf epe-links {
        type uint32;
        description "Number of EPE links";
      }

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

      leaf epesids {
        type uint32;
        description
          "Number of total EPE SIDs";
      }

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

      leaf un-protected-adjacency-sids {
        type uint32;
        description
          "Number of unprotected adjacency SIDs";
      }

      leaf topology-consistent {
        type boolean;
        description
          "True if topology is consistent";
      }
    }  // grouping PCE-NODE-SUMMARY-BAG

    grouping SRV6-NODE-SID-BAG {
      description "SRv6 Node SID bag";
      container srv6sid {
        description "SRv6 node SID";
        uses SRV6-SID-BAG;
      }  // container srv6sid

      container node-id {
        description
          "Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

      leaf domain-identifier {
        type uint64;
        description "Domain identifier";
      }
    }  // grouping SRV6-NODE-SID-BAG

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

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

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

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

      leaf local-interface-index {
        type uint32;
        description
          "Non-zero if IsUnnumbered is True";
      }

      leaf remote-interface-index {
        type uint32;
        description
          "Non-zero if IsUnnumbered is True";
      }

      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 administrative-groups {
        type uint32;
        description "Link admin-groups";
      }

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

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

      leaf-list flex-algo-asla-administrative-group {
        type uint32;
        description
          "Flex-algo specific Link Extended admin-groups";
      }

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

      list srv6-adjacency-sid {
        description
          "SRv6 Adjacecny micro-SIDs";
        uses SRV6-SID-BAG;
      }  // list srv6-adjacency-sid

      list msd {
        description "Advertised MSDs";
        uses TOPO-MSD-BAG;
      }  // list msd
    }  // grouping PCE-IPV6-LINK-BAG

    grouping TOPO-MSD-BAG {
      description "Topology MSD";
      leaf subtype {
        type Topo-msd-subtype;
        description
          "Subtype of the MSD as defined by IANA";
      }

      leaf value {
        type uint8;
        description "MSD value";
      }
    }  // grouping TOPO-MSD-BAG

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

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

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

      container performance-metrics {
        description "Performance metrics";
        uses PCE-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
          "Non-zero if IsUnnumbered is True";
      }

      leaf remote-interface-index {
        type uint32;
        description
          "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-asla-te-metric {
        type uint32;
        description
          "Flex-algo specific Link TE metric";
      }

      leaf-list flex-algo-asla-administrative-group {
        type uint32;
        description
          "Flex-algo specific Link Extended admin-groups";
      }

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

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

      list msd {
        description "Advertised MSDs";
        uses TOPO-MSD-BAG;
      }  // list msd
    }  // grouping PCE-IPV4-LINK-BAG

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

      leaf sid-type {
        type Sid;
        description "SID Type";
      }

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

      leaf algorithm {
        type uint32;
        description "Prefix SID Algorithm";
      }

      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 PCE-SID-BAG

    grouping PCE-PREFIX-BAG {
      description "PCE Prefix bag";
      container pfx-sid {
        description "Prefix SID";
        uses PCE-SID-BAG;
      }  // container pfx-sid

      container node-id {
        description
          "Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

      leaf domain-identifier {
        type uint64;
        description "Domain identifier";
      }
    }  // grouping PCE-PREFIX-BAG

    grouping PCE-SRLB-INFO-BAG {
      description "PCE SRLB information bag";
      container node-id {
        description
          "Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

      leaf start {
        type uint32;
        description "SRLB start";
      }

      leaf size {
        type uint32;
        description "SRLB size";
      }

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

    grouping PCE-FA-DEFINITION {
      description "Flex-algo definition";
      leaf number {
        type uint8;
        description "Flex-Algo number";
      }

      leaf local-priority {
        type uint8;
        description "Local Priority";
      }

      leaf metric-type {
        type Cmn-metric;
        description "Metric Type";
      }

      leaf-list aff {
        type uint32;
        description "Affinity exclude any";
      }

      leaf-list affinity-include-any {
        type uint32;
        description "Affinity include any";
      }

      leaf-list affinity-include-all {
        type uint32;
        description "Affinity include all";
      }
    }  // grouping PCE-FA-DEFINITION

    grouping PCE-SR-ALGO-BAG {
      description "PCE SR Algo Information";
      container node-id {
        description
          "Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

      leaf domain-identifier {
        type uint64;
        description "Domain identifier";
      }

      leaf-list algo-participation {
        type uint8;
        description
          "Algos participated by this node";
      }

      list flex-algo-advertised-definition {
        description
          "Flex-algo definition advertised";
        uses PCE-FA-DEFINITION;
      }  // list flex-algo-advertised-definition
    }  // grouping PCE-SR-ALGO-BAG

    grouping PCE-SRGB-INFO-BAG {
      description "PCE SRGB information bag";
      container node-id {
        description
          "Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

      leaf start {
        type uint32;
        description "SRGB start";
      }

      leaf size {
        type uint32;
        description "SRGB size";
      }

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

    grouping PCE-IGP-INFO-BGP {
      description "PCE BGP Information";
      leaf router-id {
        type Pce-ipv4-address;
        description "BGP router ID";
      }

      leaf confed-asn {
        type uint32;
        description "Confederation ASN";
      }
    }  // grouping PCE-IGP-INFO-BGP

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

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

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

      leaf level {
        type uint32;
        description "ISIS level";
      }

      leaf area {
        type string;
        description "ISIS area";
      }
    }  // grouping PCE-IGP-INFO-ISIS

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

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

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

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

    grouping PCE-NODE-ID-BAG {
      description "PCE Node ID information";
      container igp {
        description
          "IGP-specific information";
        uses PCE-IGP-INFO-TYPE;
      }  // container igp

      leaf autonomous-system-number {
        type uint32;
        description
          "Autonomous System Number";
      }

      leaf ls-identifier {
        type uint32;
        description "Link-State identifier";
      }
    }  // grouping PCE-NODE-ID-BAG

    grouping PCE-IGP-INFO-BAG {
      description "PCE IGP information bag";
      container node-id {
        description
          "Link-state node identifier";
        uses PCE-NODE-ID-BAG;
      }  // container node-id

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

    grouping PCE-NODE-PID-BAG {
      description
        "PCE 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";
      }

      leaf ipv6-router-id-set {
        type boolean;
        description
          "True if the IPv6 router ID is set";
      }

      leaf ipv6-router-id {
        type inet:ipv6-address;
        description "IPv6 Router ID";
      }

      list igp-information {
        description "IGP information";
        uses PCE-IGP-INFO-BAG;
      }  // list igp-information

      list srgb-information {
        description "SRGB information";
        uses PCE-SRGB-INFO-BAG;
      }  // list srgb-information

      list sr-algo {
        description "SR Algo information";
        uses PCE-SR-ALGO-BAG;
      }  // list sr-algo

      list srlb-information {
        description "SRLB information";
        uses PCE-SRLB-INFO-BAG;
      }  // list srlb-information
    }  // grouping PCE-NODE-PID-BAG

    grouping PCE-XTC-NODE-BAG {
      description "PCE XTC Node Information";
      container node-protocol-identifier {
        description
          "Node protocol identifier";
        uses PCE-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 prefixe {
        description "Prefixes";
        uses PCE-PREFIX-BAG;
      }  // list prefixe

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

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

      list srv6-node-sid {
        description "SRv6 Node micro-SIDs";
        uses SRV6-NODE-SID-BAG;
      }  // list srv6-node-sid
    }  // grouping PCE-XTC-NODE-BAG

    grouping PCE-VIRTUAL-LINK-BAG {
      description "PCE Virtual Link Info";
      leaf local-pce-id {
        type uint32;
        description
          "Virtual link local PCE ID";
      }

      leaf remote-pce-id {
        type uint32;
        description
          "Virtual link remote PCE ID";
      }

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

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

      leaf metric {
        type uint32;
        description "Virtual link metric";
      }

      leaf label {
        type uint32;
        description "Virtual link SID Label";
      }
    }  // grouping PCE-VIRTUAL-LINK-BAG

    grouping PCE-REMOTE-PFX-BAG {
      description
        "PCE Remote Prefix Information";
      container ip {
        description
          "Remote prefix IP address";
        uses PCE-IP-ADDR-TYPE;
      }  // container ip

      leaf virtual-node-pce-id {
        type uint32;
        description "Virtual Node PCE ID";
      }

      list virtual-link {
        description "virtual links";
        uses PCE-VIRTUAL-LINK-BAG;
      }  // list virtual-link
    }  // grouping PCE-REMOTE-PFX-BAG

    grouping PCE-PEER-BAG {
      description "Peer information";
      container peer-address-xr {
        description "Peer address";
        uses PCE-IP-ADDR-TYPE;
      }  // container peer-address-xr

      container brief-pcep-information {
        description
          "PCE protocol information";
        uses PCE-PCEP-BAG;
      }  // container brief-pcep-information

      leaf peer-protocol {
        type Pce-proto;
        description
          "Protocol between PCE and peer";
      }
    }  // grouping PCE-PEER-BAG

    grouping PCE-AUTH-OPTION-BAG {
      description
        "PCE Authentication Option information";
      leaf authentication-key-type {
        type Cmn-auth;
        description
          "Authentication Key Type";
      }

      leaf password {
        type string;
        description
          "Authentication Password";
      }

      leaf authentication-option-include-options-enable {
        type boolean;
        description "Include Option Enable";
      }

      leaf authentication-option-accept-mismatch-enable {
        type boolean;
        description "Accept Mismatch Enable";
      }
    }  // grouping PCE-AUTH-OPTION-BAG

    grouping PCE-PCEP-ERROR-BAG {
      description "PCEP Error information";
      leaf pc-error-type {
        type uint8;
        description "PCEP Error type";
      }

      leaf pc-error-value {
        type uint8;
        description "PCEP Error Value";
      }
    }  // grouping PCE-PCEP-ERROR-BAG

    grouping PCE-PCEP-BAG {
      description "PCEP information";
      leaf pcep-state {
        type Pcep-state;
        description "PCEP State";
      }

      leaf stateful {
        type boolean;
        description "Stateful";
      }

      leaf capability-update {
        type boolean;
        description "Update capability";
      }

      leaf capability-instantiate {
        type boolean;
        description
          "Instantiation capability";
      }

      leaf capability-segment-routing {
        type boolean;
        description
          "Segment Routing capability";
      }

      leaf capability-triggered-sync {
        type boolean;
        description
          "Triggered Synchronization capability";
      }

      leaf capability-db-version {
        type boolean;
        description "DB version capability";
      }

      leaf capability-delta-sync {
        type boolean;
        description
          "Delta Synchronization capability";
      }
    }  // grouping PCE-PCEP-BAG

    grouping PCE-PCEP-DETAIL-BAG {
      description
        "Detailed PCE protocol information";
      container brief-pcep-information {
        description
          "Brief PCE protocol information";
        uses PCE-PCEP-BAG;
      }  // container brief-pcep-information

      container last-error-rx {
        description "Last PCError received";
        uses PCE-PCEP-ERROR-BAG;
      }  // container last-error-rx

      container last-error-tx {
        description "Last PCError sent";
        uses PCE-PCEP-ERROR-BAG;
      }  // container last-error-tx

      container pce-authentication {
        description
          "PCE Peer Authentication";
        uses PCE-AUTH-OPTION-BAG;
      }  // container pce-authentication

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

      leaf speaker-id {
        type string;
        description "Speaker Entity ID";
      }

      leaf pcep-up-time {
        type uint32;
        description "PCEP Up Time";
      }

      leaf keepalives {
        type uint32;
        description "Keepalive count";
      }

      leaf md5-enabled {
        type boolean;
        description
          "MD5 Authentication Enabled";
      }

      leaf authentication-option-keychain-enabled {
        type boolean;
        description
          "AO Keychain based Authentication Enabled";
      }

      leaf negotiated-local-keepalive {
        type uint32;
        description "Negotiated KA";
      }

      leaf negotiated-remote-keepalive {
        type uint32;
        description "Negotiated KA";
      }

      leaf negotiated-dead-time {
        type uint32;
        description "Negotiated DT";
      }

      leaf pce-request-rx {
        type uint32;
        description "PCEReq Rx";
      }

      leaf pce-request-tx {
        type uint32;
        description "PCEReq Tx";
      }

      leaf pce-reply-rx {
        type uint32;
        description "PCERep Rx";
      }

      leaf pce-reply-tx {
        type uint32;
        description "PCERep Tx";
      }

      leaf pce-error-rx {
        type uint32;
        description "PCEErr Rx";
      }

      leaf pce-error-tx {
        type uint32;
        description "PCEErr Tx";
      }

      leaf pce-open-tx {
        type uint32;
        description "PCEOpen Tx";
      }

      leaf pce-open-rx {
        type uint32;
        description "PCEOpen Rx";
      }

      leaf pce-report-rx {
        type uint32;
        description "PCERpt Rx";
      }

      leaf pce-report-tx {
        type uint32;
        description "PCERpt Tx";
      }

      leaf pce-update-rx {
        type uint32;
        description "PCEUpd Rx";
      }

      leaf pce-update-tx {
        type uint32;
        description "PCEUpd Tx";
      }

      leaf pce-initiate-rx {
        type uint32;
        description "PCEInit Rx";
      }

      leaf pce-initiate-tx {
        type uint32;
        description "PCEInit Tx";
      }

      leaf pce-keepalive-tx {
        type uint64;
        description "PCE Keepalive Tx";
      }

      leaf pce-keepalive-rx {
        type uint64;
        description "PCE Keepalive Rx";
      }

      leaf local-session-id {
        type uint8;
        description "Local PCEP session ID";
      }

      leaf remote-session-id {
        type uint8;
        description "Remote PCEP session ID";
      }

      leaf minimum-keepalive-interval {
        type uint8;
        description
          "Minimum keepalive interval for the peer";
      }

      leaf maximum-dead-interval {
        type uint8;
        description
          "Maximum dead interval for the peer";
      }

      leaf max-sid-depth {
        type uint8;
        description
          "Maximum number of labels the peer can impose";
      }
    }  // grouping PCE-PCEP-DETAIL-BAG

    grouping PCE-PEER-DETAIL-BAG {
      description
        "Detailed PCEP peer information";
      container peer-address-xr {
        description "Peer address";
        uses PCE-IP-ADDR-TYPE;
      }  // container peer-address-xr

      container detail-pcep-information {
        description
          "Detailed PCE protocol information";
        uses PCE-PCEP-DETAIL-BAG;
      }  // container detail-pcep-information

      leaf peer-protocol {
        type Pce-proto;
        description
          "Protocol between PCE and peer";
      }

      leaf max-sid-depth {
        type uint32;
        description "Maximum SID Depth";
      }
    }  // grouping PCE-PEER-DETAIL-BAG

    grouping PCE-EVENT-INFO {
      description "PCE Event information";
      leaf event-id {
        type uint32;
        description
          "Event ID in range 1 - 0xFFFFFFFF. 0 is invalid.";
      }

      leaf event-message {
        type string;
        description "Event message";
      }

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

    grouping PCE-EVENT-BAG {
      description "Private LSP information";
      list event-buffer {
        description "LSP Event buffer";
        uses PCE-EVENT-INFO;
      }  // list event-buffer
    }  // grouping PCE-EVENT-BAG

    grouping PCEP-SRPOLICY-CPATH-PREFERENCE-BAG {
      description
        "PCEP SR Policy CPATH-PREFERENCE";
      leaf preference {
        type uint32;
        description "Preference";
      }
    }  // grouping PCEP-SRPOLICY-CPATH-PREFERENCE-BAG

    grouping PCEP-SRPOLICY-CPATH-ID-BAG {
      description "PCEP SR Policy CPATH-ID";
      leaf originator-address {
        type inet:ipv6-address;
        description
          "Originator IPv6 address";
      }

      leaf originator-asn {
        type uint32;
        description "Originator AS number";
      }

      leaf discriminator {
        type uint32;
        description "Discriminator";
      }

      leaf protocol-origin {
        type uint8;
        description "Protocol origin";
      }
    }  // grouping PCEP-SRPOLICY-CPATH-ID-BAG

    grouping PCEP-SRPOLICY-POL-NAME-BAG {
      description "PCEP SR Policy Name";
      leaf policy-name {
        type string;
        description "Policy name";
      }
    }  // grouping PCEP-SRPOLICY-POL-NAME-BAG

    grouping PCEP-SRPOLICY-POL-ID-BAG {
      description "PCEP SR Policy POL-ID";
      container endpoint {
        description "Policy endpoint";
        uses XTC-IP-ADDR-TYPE;
      }  // container endpoint

      leaf color {
        type uint32;
        description "Policy color";
      }
    }  // grouping PCEP-SRPOLICY-POL-ID-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

    grouping PCEP-SRPAG-BAG {
      description
        "PCEP SR Policy Association Group";
      container srpag-asso-source {
        description "Association Source";
        uses XTC-IP-ADDR-TYPE;
      }  // container srpag-asso-source

      container policy-id-info {
        description "POL ID";
        uses PCEP-SRPOLICY-POL-ID-BAG;
      }  // container policy-id-info

      container policy-name-info {
        description "POL Name";
        uses PCEP-SRPOLICY-POL-NAME-BAG;
      }  // container policy-name-info

      container candidate-path-id-info {
        description "CPATH ID";
        uses PCEP-SRPOLICY-CPATH-ID-BAG;
      }  // container candidate-path-id-info

      container candidate-path-preference {
        description "CPATH PREFERENCE";
        uses PCEP-SRPOLICY-CPATH-PREFERENCE-BAG;
      }  // container candidate-path-preference

      leaf srpag-asso-id {
        type uint16;
        description "Association ID";
      }
    }  // grouping PCEP-SRPAG-BAG

    grouping PCE-LSPA-INFO {
      description
        "PCE LSP attribute information";
      leaf affinity-exclude-any {
        type uint32;
        description "Affinity exclude any";
      }

      leaf affinity-include-any {
        type uint32;
        description "Affinity include any";
      }

      leaf affinity-include-all {
        type uint32;
        description "Affinity include all";
      }

      leaf setup-priority {
        type uint8;
        description "Setup Priority";
      }

      leaf hold-priority {
        type uint8;
        description "Hold Priority";
      }

      leaf local-protection {
        type boolean;
        description
          "True, if local protection is desired";
      }
    }  // grouping PCE-LSPA-INFO

    grouping PCE-ASSO-INFO {
      description
        "PCE LSP association information";
      container association-source {
        description "Association Source";
        uses PCE-IP-ADDR-TYPE;
      }  // container association-source

      leaf association-type {
        type uint32;
        description "Association Type";
      }

      leaf association-id {
        type uint32;
        description "Association ID";
      }
    }  // grouping PCE-ASSO-INFO

    grouping PCE-LSP-RSVP-ERROR-BAG {
      description "RSVP error information";
      leaf node-address {
        type inet:ipv4-address;
        description
          "RSVP error node address";
      }

      leaf error-flags {
        type uint8;
        description "RSVP error flags";
      }

      leaf error-code {
        type uint8;
        description "RSVP error code";
      }

      leaf error-value {
        type uint16;
        description "RSVP error value";
      }
    }  // grouping PCE-LSP-RSVP-ERROR-BAG

    grouping PCE-PCEP-INFO {
      description "PCEP LSP information";
      container rsvp-error {
        description "RSVP error info";
        uses PCE-LSP-RSVP-ERROR-BAG;
      }  // container rsvp-error

      leaf pcepid {
        type uint32;
        description
          "PCE protocol identifier";
      }

      leaf pcep-flag-d {
        type boolean;
        description
          "PCEP LSP delegation flag";
      }

      leaf pcep-flag-s {
        type boolean;
        description
          "PCEP LSP state-sync flag";
      }

      leaf pcep-flag-r {
        type boolean;
        description "PCEP LSP remove flag";
      }

      leaf pcep-flag-a {
        type boolean;
        description "PCEP LSP admin flag";
      }

      leaf pcep-flag-o {
        type uint8;
        description
          "PCEP LSP operation flag";
      }

      leaf pcep-flag-c {
        type uint8;
        description
          "PCEP LSP initiated flag";
      }
    }  // grouping PCE-PCEP-INFO

    grouping PCE-RRO-INFO {
      description "RRO information";
      container sr-rro {
        description
          "Segment Routing RRO info";
        uses PCE-SR-HOP-TYPE;
      }  // container sr-rro

      leaf rro-type {
        type Pce-rro;
        description "RRO Type";
      }

      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPv4 address of RRO";
      }

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

      leaf flags {
        type uint8;
        description "RRO Flags";
      }
    }  // grouping PCE-RRO-INFO

    grouping SRV6-SID-BAG {
      description "PCE SRv6 SID bag";
      container endpoint-function {
        description
          "Endpoint behavior of the SRv6SID";
        uses MGMT-SRV6-ENDPOINT-BEHAVIOR;
      }  // container endpoint-function

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

      leaf srv6sid {
        type inet:ipv6-address;
        description "Full SRv6 SID";
      }

      leaf type {
        type uint8;
        description "SRv6 SID Type";
      }

      leaf flags {
        type uint8;
        description "SRv6 SID flags";
      }

      leaf algorithm {
        type uint8;
        description
          "Flex-Algo value used for this SRv6SID";
      }

      leaf weight {
        type uint8;
        description "Weight";
      }
    }  // grouping SRV6-SID-BAG

    grouping PCE-SR-HOP-TYPE {
      description "SR hop type";
      container local-addr {
        description "Local Address";
        uses PCE-IP-ADDR-TYPE;
      }  // container local-addr

      container remote-addr {
        description "Remote Address";
        uses PCE-IP-ADDR-TYPE;
      }  // container remote-addr

      container srv6sid {
        description "SRv6 SID";
        uses SRV6-SID-BAG;
      }  // container srv6sid

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

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

      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";
      }
    }  // grouping PCE-SR-HOP-TYPE

    grouping PCE-RSVP-HOP-TYPE {
      description "RSVP hop type";
      leaf hop-address {
        type inet:ipv4-address;
        description "RSVP hop address";
      }

      leaf loose {
        type boolean;
        description "Loose hop";
      }
    }  // grouping PCE-RSVP-HOP-TYPE

    grouping PCE-ERO-INFO {
      description "ERO information";
      leaf reported-metric-type {
        type uint32;
        description "Reported Metric Type";
      }

      leaf reported-metric-value {
        type uint32;
        description "Reported Metric Value";
      }

      leaf computed-metric-type {
        type uint32;
        description "Computed Metric Type";
      }

      leaf computed-metric-value {
        type uint32;
        description "Computed Metric Value";
      }

      leaf computed-hop-list-time {
        type uint32;
        description "Computed Hop List Time";
      }

      list reported-rsvp-path {
        description "Reported RSVP path";
        uses PCE-RSVP-HOP-TYPE;
      }  // list reported-rsvp-path

      list reported-sr-path {
        description "Reported SR path";
        uses PCE-SR-HOP-TYPE;
      }  // list reported-sr-path

      list computed-rsvp-path {
        description "Computed RSVP path";
        uses PCE-RSVP-HOP-TYPE;
      }  // list computed-rsvp-path

      list computed-sr-path {
        description "Computed SR path";
        uses PCE-SR-HOP-TYPE;
      }  // list computed-sr-path
    }  // grouping PCE-ERO-INFO

    grouping PCE-LSP-DETAIL-INFO {
      description "Detailed LSP information";
      container brief-lsp-information {
        description "Brief LSP information";
        uses PCE-LSP-INFO;
      }  // container brief-lsp-information

      container er-os {
        description "Paths";
        uses PCE-ERO-INFO;
      }  // container er-os

      container lsppcep-information {
        description
          "PCEP related LSP information";
        uses PCE-PCEP-INFO;
      }  // container lsppcep-information

      container lsp-association-info {
        description
          "LSP association information";
        uses PCE-ASSO-INFO;
      }  // container lsp-association-info

      container lsp-attributes {
        description "LSP attributes";
        uses PCE-LSPA-INFO;
      }  // container lsp-attributes

      container sub-delegated-pce {
        description "Sub delegated PCE";
        uses PCE-IP-ADDR-TYPE;
      }  // container sub-delegated-pce

      container state-sync-pce {
        description "State-sync PCE";
        uses PCE-IP-ADDR-TYPE;
      }  // container state-sync-pce

      container reporting-pcc-address {
        description "Reporting PCC address";
        uses PCE-IP-ADDR-TYPE;
      }  // container reporting-pcc-address

      container srpag-info {
        description
          "SR Policy Association Group";
        uses PCEP-SRPAG-BAG;
      }  // container srpag-info

      leaf signaled-bandwidth-specified {
        type boolean;
        description
          "True if router notifies signal bandwidth";
      }

      leaf signaled-bandwidth {
        type uint64;
        description "Signaled Bandwidth";
      }

      leaf actual-bandwidth-specified {
        type boolean;
        description
          "True if router notifies actual bandwidth";
      }

      leaf actual-bandwidth {
        type uint64;
        description
          "Actual bandwidth utilized in the data-plane";
      }

      leaf lsp-role {
        type uint32;
        description "LSP Role";
      }

      leaf computing-pce {
        type uint32;
        description "Computing PCE";
      }

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

      leaf protection-type {
        type uint32;
        description "Protection Type";
      }

      leaf invalidated-traffic-dropped {
        type boolean;
        description
          "Invalidated Traffic Dropped";
      }

      leaf-list srlg-info {
        type uint32;
        description
          "List of SLRGs used by LSP";
      }

      list rro {
        description "RRO";
        uses PCE-RRO-INFO;
      }  // list rro
    }  // grouping PCE-LSP-DETAIL-INFO

    grouping PCE-TUN-DETAIL-BAG {
      description
        "Tunnel detail information";
      container pcc-address {
        description "PCC address";
        uses PCE-IP-ADDR-TYPE;
      }  // container pcc-address

      container private-lsp-information {
        description
          "Private LSP information";
        uses PCE-EVENT-BAG;
      }  // container private-lsp-information

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

      leaf xtc-controlled {
        type boolean;
        description
          "Allow XTC reoptimizations";
      }

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

      leaf interface-name {
        type string;
        description "Interface name";
      }

      leaf profile-id {
        type uint16;
        description "Profile ID";
      }

      leaf is-zombie {
        type boolean;
        description
          "PCC has disconnected, but tunnel still kept
         around";
      }

      list detail-lsp-information {
        description "Detail LSP information";
        uses PCE-LSP-DETAIL-INFO;
      }  // list detail-lsp-information
    }  // grouping PCE-TUN-DETAIL-BAG

    grouping PCE-LSP-COUNTS-BAG {
      description "Number of LSPs";
      leaf all-ls-ps {
        type uint32;
        description "Number of all LSPs";
      }

      leaf up-ls-ps {
        type uint32;
        description
          "Number of operational LSPs";
      }

      leaf admin-up-ls-ps {
        type uint32;
        description
          "Number of administratively up LSPs";
      }

      leaf sr-ls-ps {
        type uint32;
        description
          "Number of LSPs with Segment routing setup type";
      }

      leaf rsvp-ls-ps {
        type uint32;
        description
          "Number of LSPs with RSVP setup type";
      }
    }  // grouping PCE-LSP-COUNTS-BAG

    grouping PCE-LSP-PER-PEER-SUMMARY-BAG {
      description
        "Number of LSPs for specific peer";
      container lsp-summary {
        description
          "Number of LSPs for specific peer";
        uses PCE-LSP-COUNTS-BAG;
      }  // container lsp-summary

      container peer-address {
        description "Peer address";
        uses PCE-IP-ADDR-TYPE;
      }  // container peer-address
    }  // grouping PCE-LSP-PER-PEER-SUMMARY-BAG

    grouping PCE-LSP-SUMMARY-BAG {
      description
        "PCE LSP summary information";
      container all-ls-ps {
        description "Summary for all peers";
        uses PCE-LSP-COUNTS-BAG;
      }  // container all-ls-ps

      list peer-ls-ps-info {
        description
          "Number of LSPs for specific peer";
        uses PCE-LSP-PER-PEER-SUMMARY-BAG;
      }  // list peer-ls-ps-info
    }  // grouping PCE-LSP-SUMMARY-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 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 PCE-SRV6-BSID-INFO {
      description "SRv6 Binding SID Info";
      container binding-sid-prefix {
        description
          "SRv6 Binding SID prefix";
        uses PCE-IP-ADDR-TYPE;
      }  // container binding-sid-prefix

      container binding-sid-behavior {
        description "Binding SID behavior";
        uses MGMT-SRV6-ENDPOINT-BEHAVIOR;
      }  // container binding-sid-behavior

      container structure {
        description
          "The SRv6 strucutre of the SID";
        uses SRV6-SID-STRUCTURE-BAG;
      }  // container structure
    }  // grouping PCE-SRV6-BSID-INFO

    grouping PCE-LSP-INFO {
      description "LSP common information";
      container source-address {
        description "Source address";
        uses PCE-IP-ADDR-TYPE;
      }  // container source-address

      container destination-address {
        description "Destination address";
        uses PCE-IP-ADDR-TYPE;
      }  // container destination-address

      container srv6-binding-sid {
        description "SRv6 Binding SID";
        uses PCE-SRV6-BSID-INFO;
      }  // container srv6-binding-sid

      leaf tunnel-id {
        type uint32;
        description "Tunnel ID";
      }

      leaf lspid {
        type uint32;
        description "LSP ID";
      }

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

      leaf lsp-setup-type {
        type Lsp-setup;
        description "LSP Setup Type";
      }

      leaf operational-state {
        type Pcep-lsp-state;
        description "Operational state";
      }

      leaf administrative-state {
        type Lsp-state;
        description "Administrative state";
      }

      leaf msd {
        type uint32;
        description "Maximum SID Depth";
      }

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

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

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

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

      leaf latency-bound {
        type uint32;
        description "Latency Metric Bound";
      }

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

      leaf anycast-sid-inclusion {
        type uint32;
        description "Anycast SID Inclusion";
      }
    }  // grouping PCE-LSP-INFO

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

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

      leaf ipv6 {
        when "../af-name = 'ipv6'" {
          description "../AFName = 'IPv6'";
        }
        type Pce-ipv6-address;
        description "IPv6 address type";
      }
    }  // grouping PCE-IP-ADDR-TYPE

    grouping PCE-TUN-BAG {
      description "Tunnel information";
      container pcc-address {
        description "PCC address";
        uses PCE-IP-ADDR-TYPE;
      }  // container pcc-address

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

      list brief-lsp-information {
        description "Brief LSP information";
        uses PCE-LSP-INFO;
      }  // list brief-lsp-information
    }  // grouping PCE-TUN-BAG
  }  // submodule Cisco-IOS-XR-infra-xtc-oper-sub1