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

    yang-version 1;

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

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

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

    organization "Cisco Systems, Inc.";

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

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

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

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

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

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

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

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

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

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

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

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

    typedef Tcp-auth {
      type enumeration {
        enum "tcp-authentication-none" {
          value 0;
          description
            "TCP Authentication None";
        }
        enum "tcp-authentication-keychain" {
          value 1;
          description "TCP EA Keychain";
        }
        enum
          "tcp-authentication-password-clear" {
          value 2;
          description "MD5 password clear";
        }
        enum
          "tcp-authentication-password-encrypted" {
          value 3;
          description
            "MD5 password encrypted";
        }
        enum "tcp-authentication-option" {
          value 4;
          description
            "TCP Authentication Option";
        }
      }
      description "TCP authentication type";
    }

    grouping PCEP-CONN-PWD-BAG {
      description
        "PCEP connection password information";
      leaf type {
        type Tcp-auth;
        description "password type";
      }

      leaf keychain-name {
        type string;
        description "Keychain Name";
      }

      leaf md5-password {
        type string;
        description "MD5 Password";
      }

      leaf ao-keychain-name {
        type string;
        description
          "Authentication Option Keychain Name";
      }

      leaf ao-include-options-enable {
        type boolean;
        description
          "AO Include Option Enable";
      }

      leaf ao-accept-mismatch-enable {
        type boolean;
        description
          "AO Accept Mismatch Enable";
      }
    }  // grouping PCEP-CONN-PWD-BAG

    grouping PCEP-CONN-STATS-BAG {
      description
        "PCEP CONN STATS information";
      leaf ka-msg-rx {
        type uint64;
        description "KA messages rxed";
      }

      leaf ka-msg-fail-rx {
        type uint64;
        description "KA messages fail rxed";
      }

      leaf ka-msg-tx {
        type uint64;
        description "KA messages txed";
      }

      leaf ka-msg-fail-tx {
        type uint64;
        description "KA messages fail txed";
      }

      leaf pcreq-msg-rx {
        type uint64;
        description "PCREQ messages rxed";
      }

      leaf pcreq-msg-fail-rx {
        type uint64;
        description
          "PCREQ messages fail rxed";
      }

      leaf pcreq-msg-tx {
        type uint64;
        description "PCREQ messages txed";
      }

      leaf pcreq-msg-fail-tx {
        type uint64;
        description
          "PCREQ messages fail txed";
      }

      leaf pcrep-msg-rx {
        type uint64;
        description "PCREP messages rxed";
      }

      leaf pcrep-msg-fail-rx {
        type uint64;
        description
          "PCREP messages fail rxed";
      }

      leaf pcrep-msg-tx {
        type uint64;
        description "PCREP messages txed";
      }

      leaf pcrep-msg-fail-tx {
        type uint64;
        description
          "PCREP messages fail txed";
      }

      leaf pcrpt-msg-rx {
        type uint64;
        description "PCRPT messages rxed";
      }

      leaf pcrpt-msg-fail-rx {
        type uint64;
        description
          "PCRPT messages fail rxed";
      }

      leaf pcrpt-msg-tx {
        type uint64;
        description "PCRPT messages txed";
      }

      leaf pcrpt-msg-fail-tx {
        type uint64;
        description
          "PCRPT messages fail txed";
      }

      leaf pcupd-msg-rx {
        type uint64;
        description "PCUPD messages rxed";
      }

      leaf pcupd-msg-fail-rx {
        type uint64;
        description
          "PCUPD messages fail rxed";
      }

      leaf pcupd-msg-tx {
        type uint64;
        description "PCUPD messages txed";
      }

      leaf pcupd-msg-fail-tx {
        type uint64;
        description
          "PCUPD messages fail txed";
      }

      leaf open-msg-rx {
        type uint64;
        description "OPEN messages rxed";
      }

      leaf open-msg-fail-rx {
        type uint64;
        description
          "OPEN messages fail rxed";
      }

      leaf open-msg-tx {
        type uint64;
        description "OPEN messages txed";
      }

      leaf open-msg-fail-tx {
        type uint64;
        description
          "OPEN messages fail txed";
      }

      leaf pcerr-msg-rx {
        type uint64;
        description "PCERR messages rxed";
      }

      leaf pcerr-msg-fail-rx {
        type uint64;
        description
          "PCERR messages fail rxed";
      }

      leaf pcerr-msg-tx {
        type uint64;
        description "PCERR messages txed";
      }

      leaf pcerr-msg-fail-tx {
        type uint64;
        description
          "PCERR messages fail txed";
      }

      leaf pcntf-msg-rx {
        type uint64;
        description "PCNTF messages rxed";
      }

      leaf pcntf-msg-fail-rx {
        type uint64;
        description
          "PCNTF messages fail rxed";
      }

      leaf pcntf-msg-tx {
        type uint64;
        description "PCNTF messages txed";
      }

      leaf pcntf-msg-fail-tx {
        type uint64;
        description
          "PCNTF messages fail txed";
      }

      leaf pce-eos-msg-tx {
        type uint64;
        description "PCE EOS messages txed";
      }

      leaf pce-eos-msg-fail-tx {
        type uint64;
        description
          "PCE EOS messages fail txed";
      }

      leaf close-msg-rx {
        type uint64;
        description "CLOSE messages rxed";
      }

      leaf close-msg-fail-rx {
        type uint64;
        description
          "CLOSE messages fail rxed";
      }

      leaf close-msg-tx {
        type uint64;
        description "CLOSE messages txed";
      }

      leaf close-msg-fail-tx {
        type uint64;
        description
          "CLOSE messages fail txed";
      }

      leaf unexpected-msg-rx {
        type uint64;
        description
          "Unexpected messages rxed";
      }

      leaf corrupted-msg-rx {
        type uint64;
        description
          "Corrupted messages rxed";
      }

      leaf reply-time-index {
        type uint32;
        description
          "index into recorded reply time";
      }

      leaf minimum-reply-time {
        type uint64;
        description "min reply time";
      }

      leaf maximum-reply-time {
        type uint64;
        description "max reply time";
      }

      leaf requests-timed-out {
        type uint64;
        description "requests timed out";
      }

      leaf last-pcerr-type-rx {
        type uint8;
        description
          "last PCERR type received";
      }

      leaf last-pcerr-val-rx {
        type uint8;
        description
          "last PCERR value received";
      }

      leaf last-pcerr-rx-ts {
        type uint64;
        description
          "last time when PCERR was received";
      }

      leaf last-pcerr-type-tx {
        type uint8;
        description
          "last PCERR type transmitted";
      }

      leaf last-pcerr-val-tx {
        type uint8;
        description
          "last PCERR value transmitted";
      }

      leaf last-pcerr-tx-ts {
        type uint64;
        description
          "last time when PCERR was transmitted";
      }

      leaf pcinitiate-msg-rx {
        type uint64;
        description
          "PCINITIATE messages rxed";
      }

      leaf pcinitiate-msg-fail-rx {
        type uint64;
        description
          "PCINITIATE messages fail rxed";
      }

      leaf-list recorded-reply-time {
        type uint64;
        max-elements 10;
        description "Recorded reply time";
      }
    }  // grouping PCEP-CONN-STATS-BAG

    grouping PCEP-SOCKET-BAG {
      description "PCEP SOCKET information";
      leaf fd {
        type int64;
        description "file descriptor";
      }

      leaf wnotify {
        type boolean;
        description "write notify";
      }

      leaf rnotify {
        type boolean;
        description "read notify";
      }

      leaf refcnt {
        type uint32;
        description "ref count";
      }

      leaf selected {
        type boolean;
        description "selected";
      }

      leaf owner {
        type uint32;
        description "owner";
      }

      leaf csockaddr-str {
        type string;
        description "client address";
      }

      leaf ssockaddr-str {
        type string;
        description "server address";
      }
    }  // grouping PCEP-SOCKET-BAG

    grouping PCEP-CONN-BAG {
      description "PCEP CONN information";
      container socket-info {
        description "socket info";
        uses PCEP-SOCKET-BAG;
      }  // container socket-info

      container pcep-server-addr {
        description "PCEP server address";
        uses XTC-IP-ADDR-TYPE;
      }  // container pcep-server-addr

      container pcep-client-addr {
        description "PCEP client address";
        uses XTC-IP-ADDR-TYPE;
      }  // container pcep-client-addr

      container stats {
        description "stats";
        uses PCEP-CONN-STATS-BAG;
      }  // container stats

      container password {
        description "Password Information";
        uses PCEP-CONN-PWD-BAG;
      }  // container password

      leaf handle {
        type uint32;
        description "internal handle";
      }

      leaf state-str {
        type string;
        description "connection state";
      }

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

      leaf local-ok {
        type boolean;
        description "local accepted";
      }

      leaf remote-ok {
        type boolean;
        description "remote accepted";
      }

      leaf open-retry {
        type uint32;
        description "open retry count";
      }

      leaf ref-cnt {
        type uint32;
        description "ref count";
      }

      leaf rx-state-str {
        type string;
        description "socket state";
      }

      leaf holddown-counter {
        type uint16;
        description "holddown counter";
      }

      leaf pcep-up-ts {
        type uint64;
        description "PCEP up timestamp";
      }

      leaf precedence {
        type uint8;
        description "Precedence";
      }

      leaf ka-interval-local {
        type uint32;
        description "KA interval local";
      }

      leaf ka-interval-remote {
        type uint32;
        description "KA interval remote";
      }

      leaf dead-interval-local {
        type uint32;
        description "Dead interval local";
      }

      leaf dead-interval-remote {
        type uint32;
        description "Dead interval remote";
      }

      leaf pcep-session-id-local {
        type uint32;
        description "PCEP session ID local";
      }

      leaf pcep-session-id-remote {
        type uint32;
        description "PCEP session ID remote";
      }

      leaf pcep-server-ipv4-addr {
        type inet:ipv4-address;
        description
          "PCEP server Ipv4 address";
      }

      leaf pcep-client-ipv4-addr {
        type inet:ipv4-address;
        description
          "PCEP client Ipv4 address";
      }

      leaf is-stateful-local {
        type boolean;
        description "is stateful local";
      }

      leaf is-stateful-remote {
        type boolean;
        description "is stateful remote";
      }

      leaf is-stateful-u-flag-local {
        type boolean;
        description
          "is stateful with U flag local";
      }

      leaf is-stateful-u-flag-remote {
        type boolean;
        description
          "is stateful with U flag remote";
      }

      leaf is-segment-routing-local {
        type boolean;
        description
          "is segment routing local";
      }

      leaf is-segment-routing-remote {
        type boolean;
        description
          "is segment routing remote";
      }

      leaf is-initiate-local {
        type boolean;
        description
          "local initiate capability";
      }

      leaf is-initiate-remote {
        type boolean;
        description
          "remote initiate capability";
      }

      leaf is-best-pce {
        type boolean;
        description
          "is this the best PCE to delegate to";
      }

      leaf sr-msd-local {
        type uint8;
        description "SR MSD local";
      }

      leaf sr-msd-remote {
        type uint8;
        description "SR MSD remote";
      }
    }  // grouping PCEP-CONN-BAG

    grouping PCEP-HOP-SR-IPV4 {
      description
        "PCEP SR IPv4 hop information";
      leaf type {
        type uint8;
        description "SID type";
      }

      leaf cflag {
        type boolean;
        description "C flag";
      }

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

      leaf remote-addr {
        type uint32;
        description "Remote address";
      }

      leaf local-addr {
        type uint32;
        description "Local address";
      }
    }  // grouping PCEP-HOP-SR-IPV4

    grouping PCEP-HOP-IPV4 {
      description
        "PCEP IPv4 hop information";
      leaf v4-addr {
        type uint32;
        description "IPv4 prefix";
      }

      leaf prefix-len {
        type uint8;
        description "Prefix length";
      }
    }  // grouping PCEP-HOP-IPV4

    grouping PCEP-HOP-DATA {
      description "PCEP HOP DATA";
      container ipv4 {
        when
          "../hop-type = 'pcep-hop-type-ipv4'" {
          description
            "../HopType = 'PCEP_HOP_TYPE_IPV4'";
        }
        description "IPv4 hop info";
        uses PCEP-HOP-IPV4;
      }  // container ipv4

      container sr-v4 {
        when
          "../hop-type = 'pcep-hop-type-srv4'" {
          description
            "../HopType = 'PCEP_HOP_TYPE_SRV4'";
        }
        description "SR IPv4 hop info";
        uses PCEP-HOP-SR-IPV4;
      }  // container sr-v4

      leaf hop-type {
        type uint8;
        description "HopType";
      }
    }  // grouping PCEP-HOP-DATA

    grouping PCEP-HOP-BAG {
      description "PCEP HOP information";
      container data {
        description "data";
        uses PCEP-HOP-DATA;
      }  // container data

      leaf loose {
        type boolean;
        description "is loose hop";
      }
    }  // grouping PCEP-HOP-BAG

    grouping PCEP-PATH-STATS-BAG {
      description "PCEP PATH stats";
      leaf reports-requested {
        type uint64;
        description "Reports requested";
      }

      leaf reports-sent {
        type uint64;
        description "Reports sent";
      }

      leaf reports-failed-to-send {
        type uint64;
        description "Reports failed";
      }
    }  // grouping PCEP-PATH-STATS-BAG

    grouping PCEP-PATH-BAG {
      description "PCEP PATH information";
      container stats {
        description "stats";
        uses PCEP-PATH-STATS-BAG;
      }  // container stats

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

      leaf used-bw {
        type int64;
        description "used bw";
      }

      leaf requested-bw {
        type int64;
        description "requested bw";
      }

      leaf metric-value {
        type int64;
        description "metric value";
      }

      leaf refcnt {
        type int64;
        description "refcnt";
      }

      leaf lsp-plsp-id {
        type uint32;
        description "LSP PLSP ID";
      }

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

      leaf lsp-id-tlv-ext-tunnel-id {
        type uint32;
        description "Ext Tun ID";
      }

      leaf lsp-id-tlv-tunnel-endpoint-address {
        type uint32;
        description "Tun endpoint address";
      }

      leaf lsp-id-tlv-tunnel-sender-address {
        type uint32;
        description "Tun sender address";
      }

      leaf srp-id {
        type uint32;
        description "SRP ID";
      }

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

      leaf lsp-id-tlv-tunnel-id {
        type uint16;
        description "Tunnel ID";
      }

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

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

      leaf lsp-oper {
        type uint8;
        description "LSP oper flags";
      }

      leaf path-setup-type {
        type uint8;
        description "Path setup type";
      }

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

      leaf is-reported {
        type boolean;
        description "is reported";
      }

      leaf lsp-a-flag {
        type boolean;
        description "LSP A Flag";
      }

      leaf lsp-r-flag {
        type boolean;
        description "LSP R Flag";
      }

      leaf lsp-s-flag {
        type boolean;
        description "LSP S Flag";
      }

      leaf lsp-d-flag {
        type boolean;
        description "LSP D Flag";
      }

      leaf lsp-c-flag {
        type boolean;
        description "LSP C Flag";
      }

      list ero-hop {
        description "ero hop";
        uses PCEP-HOP-BAG;
      }  // list ero-hop

      list rro-hop {
        description "rro hop";
        uses PCEP-HOP-BAG;
      }  // list rro-hop
    }  // grouping PCEP-PATH-BAG

    grouping PCEP-PLSP-EVENT-BAG {
      description "PCEP PLSP event";
      leaf ts {
        type uint64;
        description "Timestamp";
      }

      leaf desc {
        type string;
        description "Description";
      }
    }  // grouping PCEP-PLSP-EVENT-BAG

    grouping PCEP-PLSP-STATS-BAG {
      description "PCEP PLSP stats";
      leaf paths-created {
        type uint64;
        description "Paths Created";
      }

      leaf paths-destroyed {
        type uint64;
        description "Paths Destroyed";
      }

      leaf path-create-errors {
        type uint64;
        description "Path create errors";
      }

      leaf path-destroy-errors {
        type uint64;
        description "Path destroy errors";
      }

      leaf requests-created {
        type uint64;
        description "Requests created";
      }

      leaf requests-destroyed {
        type uint64;
        description "Requests destroyed";
      }

      leaf requests-failed {
        type uint64;
        description "Requests failed";
      }
    }  // grouping PCEP-PLSP-STATS-BAG

    grouping PCEP-PLSP-BAG {
      description "PCEP PLSP information";
      container stats {
        description "Stats";
        uses PCEP-PLSP-STATS-BAG;
      }  // container stats

      leaf plsp-id-xr {
        type uint32;
        description "PLSP ID";
      }

      leaf sym-path-name {
        type string;
        description "Symbolic Path Name";
      }

      leaf refcnt {
        type int64;
        description "Refcnt";
      }

      leaf conn-delegated-to {
        type uint32;
        description "CONN delegated to";
      }

      list event-history {
        max-elements 10;
        description "event history";
        uses PCEP-PLSP-EVENT-BAG;
      }  // list event-history

      list path {
        description "path";
        uses PCEP-PATH-BAG;
      }  // list path
    }  // grouping PCEP-PLSP-BAG
  }  // submodule Cisco-IOS-XR-infra-xtc-agent-oper-sub3