submodule Cisco-IOS-XR-mpls-ldp-mldp-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-mpls-ldp-mldp-oper {
        prefix
          Cisco-IOS-XR-mpls-ldp-mldp-oper;
    }

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

    organization "Cisco Systems, Inc.";

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

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

    revision "2020-10-18" {
      description
        "Backward compatible removal in telemetry event Cisco-IOS-XR-types, event-telemetry was removed.";
    }

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

    revision "2018-08-30" {
      description
        "Operational Yang model for mLDP.";
    }

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

    semver:module-version "1.1.0";
    semver:module-version "1.1.0";

    grouping MLDP-NEIGHBOR-IDENT-BAG {
      description
        "MLDP Neighbor Identity Information";
      leaf address {
        type inet:ipv4-address;
        description
          "MLDP neighbor identity address";
      }
    }  // grouping MLDP-NEIGHBOR-IDENT-BAG

    grouping MLDP-NEIGHBOR-ADJ-BAG {
      description
        "MLDP Neighbor Adjacency Information";
      leaf address {
        type inet:ipv4-address;
        description
          "MLDP neighbor adjacency address";
      }

      leaf interface-name {
        type string {
          length "0..65";
        }
        description
          "MLDP neighbor adjacency interface";
      }

      leaf checkpoint-stale {
        type boolean;
        description
          "MLDP neighbor adj info via checkpoint";
      }

      leaf graceful-restart-stale {
        type boolean;
        description
          "MLDP neighbor adj stale due to GR";
      }

      leaf confict-ignore {
        type boolean;
        description
          "Ignore this adjacency due to conflict";
      }
    }  // grouping MLDP-NEIGHBOR-ADJ-BAG

    grouping MLDP-NEIGHBOR-PATH-BAG {
      description
        "MLDP Neighbor Path Information";
      leaf neighbor-address {
        type inet:ipv4-address;
        description
          "MLDP neighbor path address";
      }

      leaf interface-name {
        type string {
          length "0..65";
        }
        description
          "MLDP neighbor path interface";
      }

      leaf mldp-adjacency {
        type boolean;
        description "MLDP adjacency present";
      }

      leaf checkpoint-stale {
        type boolean;
        description
          "MLDP neighbor path info via checkpoint";
      }

      leaf disabled {
        type uint32;
        description
          "MLDP neighbor path is disabled";
      }
    }  // grouping MLDP-NEIGHBOR-PATH-BAG

    grouping MLDP-NEIGHBOR-BAG {
      description
        "MLDP Neighbor Information";
      leaf identity-string {
        type string {
          length "0..32";
        }
        description "MLDP Identity string";
      }

      leaf capabilities {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "MLDP neighbor capabilities";
      }

      leaf up-time {
        type uint32;
        units "millisecond";
        description
          "MLDP neighbor uptime in milli-seconds";
      }

      leaf down {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "MLDP neighbor is marked as down";
      }

      leaf target-adjacency {
        type boolean;
        description
          "MLDP neighbor is targetted";
      }

      leaf session-handle {
        type uint32;
        description
          "MLDP neighbor session handle";
      }

      leaf upstream-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "MLDP neighbor Upstream LSP count";
      }

      leaf branch-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "MLDP neighbor branch count";
      }

      leaf graceful-restart-enabled {
        type boolean;
        description
          "Graceful restart enabled";
      }

      leaf graceful-restart-active {
        type boolean;
        description
          "LDP is in Graceful restart mode";
      }

      leaf graceful-restart-instance {
        type uint32;
        description
          "Graceful restart instance";
      }

      leaf graceful-restart-reconnect-time {
        type uint32;
        description "GR reconnect time";
      }

      leaf label-map-timer {
        type int32;
        units "millisecond";
        description
          "Label Mapping timer in milli-seconds";
      }

      leaf checkpoint-stale {
        type boolean;
        description
          "MLDP neighbor information via checkpoint";
      }

      leaf path-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "MLDP neighbor path count";
      }

      leaf adjacency-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "MLDP neighbor adjacency count";
      }

      leaf inbound-neighbor-policy {
        type string {
          length "0..256";
        }
        description
          "Inbound Neighbor Policy";
      }

      leaf outbound-neighbor-policy {
        type string {
          length "0..256";
        }
        description
          "Outbound Neighbor Policy";
      }

      leaf peer-identity-count {
        type uint32;
        description
          "MLDP peer identify count";
      }

      list neighbor-path {
        description "Path List";
        uses MLDP-NEIGHBOR-PATH-BAG;
      }  // list neighbor-path

      list neighbor-adjacency {
        description "Adjacency List";
        uses MLDP-NEIGHBOR-ADJ-BAG;
      }  // list neighbor-adjacency

      list peer-identity {
        description "Identity List";
        uses MLDP-NEIGHBOR-IDENT-BAG;
      }  // list peer-identity
    }  // grouping MLDP-NEIGHBOR-BAG

    grouping MLDP-TABLE-BAG {
      description "MLDP Table Information";
      leaf table-name {
        type string {
          length "0..32";
        }
        description "Table name";
      }

      leaf rib-converged {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "RIB table converged";
      }

      leaf rib-table-id {
        type uint32;
        description "RIB Table ID";
      }
    }  // grouping MLDP-TABLE-BAG

    grouping MLDP-CONTEXT-BAG {
      description "MLDP Context Information";
      leaf vrf-name {
        type string {
          length "0..33";
        }
        description "VRF name";
      }

      leaf active-table-name {
        type string {
          length "0..32";
        }
        description
          "Active RIB Table Name for this VRF";
      }

      leaf lsp-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "Number of P2MP/MP2MP LSPs in the vrf";
      }

      leaf peer-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "Number of mLDP neighbors in the vrf";
      }

      leaf mu-rib-enabled {
        type boolean;
        description "MuRIB is enabled";
      }

      leaf multi-path-upstream-enabled {
        type boolean;
        description
          "Multi-path Upstream is enabled";
      }

      leaf multi-path-downstream-enabled {
        type boolean;
        description
          "Multi-path Downstream is enabled";
      }

      leaf make-before-break-delay {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        units "millisecond";
        description
          "Make-before-break delay in milli-seconds";
      }

      leaf mldp-table-count {
        type uint32;
        description "Number of mLDP tables";
      }

      list mldp-table {
        description "List of mLDP tables";
        uses MLDP-TABLE-BAG;
      }  // list mldp-table
    }  // grouping MLDP-CONTEXT-BAG

    grouping MLDP-ROOT-IPMSI-BAG {
      description
        "MLDP Root I-PMSI Information";
      leaf next-hop-address-ipv4 {
        type inet:ipv4-address;
        description
          "IPMSI IPv4 next-hop address";
      }

      leaf next-hop-address-ipv6 {
        type inet:ipv4-address;
        description
          "IPMSI IPv6 next-hop address";
      }

      leaf rd-name {
        type string {
          length "0..65";
        }
        description "RD name";
      }
    }  // grouping MLDP-ROOT-IPMSI-BAG

    grouping MLDP-ROOT-PATH-BAG {
      description
        "MLDP Root Path Information";
      leaf root-address {
        type inet:ipv4-address;
        description "Root address";
      }

      leaf mldp-identity-string {
        type string {
          length "0..32";
        }
        description "MLDP neighbor identity";
      }

      leaf checkpoint-stale {
        type boolean;
        description
          "MLDP root path information via checkpoint";
      }

      leaf php-next-hop-address {
        type inet:ipv4-address;
        description "Penultimate next-hop";
      }
    }  // grouping MLDP-ROOT-PATH-BAG

    grouping MLDP-ROOT-BAG {
      description "MLDP Root Information";
      leaf address {
        type inet:ipv4-address;
        description "Root address";
      }

      leaf we-are-root {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "We are the root";
      }

      leaf checkpoint-stale {
        type boolean;
        description
          "MLDP root information via checkpoint";
      }

      leaf via-bgp {
        type boolean;
        description "Route learned via BGP";
      }

      leaf via-static {
        type boolean;
        description
          "Route learned via Static";
      }

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

      leaf distance {
        type uint32;
        description "Distance";
      }

      leaf interface-name {
        type string {
          length "0..65";
        }
        description "Root Interface";
      }

      leaf fec-count {
        type uint32;
        description
          "LSP's linked to this root";
      }

      leaf recursice-fec-count {
        type uint32;
        description
          "Recursive LSP's linked to this root";
      }

      leaf path-count {
        type uint32;
        description
          "Paths to reach this root";
      }

      list root-path {
        description "Root path list";
        uses MLDP-ROOT-PATH-BAG;
      }  // list root-path

      list root-ipmsi {
        description "Root I-PMSI list";
        uses MLDP-ROOT-IPMSI-BAG;
      }  // list root-ipmsi
    }  // grouping MLDP-ROOT-BAG

    grouping MLDP-NEIGHBOR-ADDR-IDENT-BAG {
      description
        "MLDP Neighbor Address Ident";
      leaf identity-string {
        type string {
          length "0..32";
        }
        description "MLDP Identity";
      }
    }  // grouping MLDP-NEIGHBOR-ADDR-IDENT-BAG

    grouping MLDP-NEIGHBOR-ADDR-BAG {
      description
        "MLDP neighbor Address Information";
      leaf address-xr {
        type inet:ipv4-address;
        description "MLDP neighbor address";
      }

      list identity {
        description "Identity List";
        uses MLDP-NEIGHBOR-ADDR-IDENT-BAG;
      }  // list identity
    }  // grouping MLDP-NEIGHBOR-ADDR-BAG

    grouping MLDP-BRANCH-BAG {
      description "MLDP Branch Information";
      leaf lsm-id {
        type uint32;
        description "LSM ID";
      }

      leaf branch-owner {
        type string {
          length "0..32";
        }
        description "Branch owner string";
      }

      leaf up-time {
        type uint32;
        units "millisecond";
        description
          "Branch uptime in milli-seconds";
      }

      leaf graceful-restart-stale {
        type boolean;
        description
          "Branch has been marked stale by graceful restart";
      }

      leaf graceful-restart-instance {
        type uint32;
        description
          "Branch graceful restart instance";
      }

      leaf mpls-label {
        type uint32;
        description "Branch Remote label";
      }

      leaf mpls-local-label-upstream {
        type uint32;
        description "Branch Local label";
      }

      leaf head-lsm-id {
        type uint32;
        description "Head LSM ID";
      }

      leaf recursive-owner-id {
        type uint32;
        description
          "Recursive Branch ownerLSM ID";
      }

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

      leaf interface-name {
        type string {
          length "0..65";
        }
        description
          "Branch next-hop interface name";
      }

      leaf interface-down {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "Interface is down";
      }

      leaf egress-interface-name {
        type string {
          length "0..64";
        }
        description "Egress interface name";
      }

      leaf vrf-name {
        type string {
          length "0..33";
        }
        description "VRF name";
      }

      leaf owner-id {
        type uint32;
        description "Branch owner ID";
      }

      leaf egress {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "Branch is Egress";
      }

      leaf mfi-peek {
        type boolean;
        description "Branch Peek is enabled";
      }

      leaf ingress {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "Branch is Ingress";
      }

      leaf ppmp {
        type boolean;
        description "Branch PPMP is enabled";
      }

      leaf drop {
        type boolean;
        description "Branch DROP is set";
      }

      leaf ordered-mode {
        type boolean;
        description
          "Branch is enabled for ordered mode";
      }

      leaf mame-before-break-request {
        type boolean;
        description
          "MBB request received on this branch";
      }

      leaf application-stale {
        type boolean;
        description
          "Branch marked stale by application";
      }

      leaf mfi-duplicate-ignore {
        type boolean;
        description
          "MFI duplicate ignore by forwarding";
      }

      leaf rpf-id {
        type uint32;
        description "Branch RPF ID";
      }

      leaf ldp-message-id {
        type uint32;
        description "Branch LDP message ID";
      }

      leaf rd-name {
        type string {
          length "0..65";
        }
        description "Recursive RD name";
      }
    }  // grouping MLDP-BRANCH-BAG

    grouping MLDP-ACEL-BAG {
      description
        "MLDP Upstream Neighbor Information";
      leaf lsm-id {
        type uint32;
        description "LSM ID";
      }

      leaf mldp-peer {
        type string {
          length "0..32";
        }
        description "MLDP Neighbor Identity";
      }

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

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

      leaf active {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "Neighbor is active";
      }

      leaf delete-pending {
        type boolean;
        description
          "Neighbor is delete pending";
      }

      leaf checkpoint-stale {
        type boolean;
        description
          "MLDP neighbor information via checkpoint";
      }

      leaf make-before-break-ack {
        type boolean;
        description
          "Make-before-break ack received";
      }

      leaf make-before-break-ack-pending {
        type boolean;
        description
          "Make-before-break ack pending";
      }

      leaf mfi-duplicate-ignore {
        type boolean;
        description
          "MFI duplicate ignore by forwarding";
      }

      leaf peer-change-delay {
        type int32;
        units "millisecond";
        description
          "Neighbor change delay in milli-seconds";
      }

      leaf delete-delay {
        type int32;
        units "millisecond";
        description
          "Upstream neighbor delete delay in milli-seconds";
      }

      leaf interface-name {
        type string {
          length "0..65";
        }
        description "Root Interface";
      }

      leaf root-address-next-hop {
        xr:event-telemetry "Subscribe Telemetry Event";
        type inet:ipv4-address;
        description "Root next-hop address";
      }

      leaf up-time {
        type uint32;
        units "millisecond";
        description
          "Neighbor uptime in milli-seconds";
      }

      leaf state-change-time {
        type uint32;
        units "millisecond";
        description
          "State change time in milli-seconds";
      }

      leaf csi-accepting {
        type boolean;
        description
          "If ACEL is CSI accepting";
      }
    }  // grouping MLDP-ACEL-BAG

    grouping MLDP-DATABASE-BAG {
      description
        "MLDP Database Information";
      leaf lsm-id-xr {
        type uint32;
        description "LSM ID";
      }

      leaf vrf-name {
        type string {
          length "0..256";
        }
        description "VRF name";
      }

      leaf up-time {
        type uint32;
        units "millisecond";
        description
          "Uptime in milli-seconds";
      }

      leaf tree-type {
        type uint32;
        description "Tree Type";
      }

      leaf root-address-xr {
        xr:event-telemetry "Subscribe Telemetry Event";
        type inet:ipv4-address;
        description "Root address";
      }

      leaf we-are-root {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "We are the root";
      }

      leaf fec-opaque-length {
        type uint32;
        description "FEC opaque length";
      }

      leaf opaque-decoded-string {
        type string {
          length "0..255";
        }
        description
          "Opaque value decoded string";
      }

      leaf fec-value-length {
        type uint32;
        description "FEC Value length";
      }

      leaf root-node-redundency-lsm-id {
        type uint32;
        description "RNR LSM-ID";
      }

      leaf root-node-redundency-active {
        type boolean;
        description "RNR Active";
      }

      leaf root-node-redundency-is-primary {
        type boolean;
        description
          "RNR Primary is this entry";
      }

      leaf root-node-redundency-lsm-id-primary {
        type uint32;
        description "RNR Primary LSM ID";
      }

      leaf root-node-redundency-root-address {
        type inet:ipv4-address;
        description "RNR Root node address";
      }

      leaf root-node-redundency-candidate-string {
        type string {
          length "0..80";
        }
        description "RNR candidate list";
      }

      leaf is-ldp-branch {
        type boolean;
        description "LDP Branch";
      }

      leaf is-local-branch {
        type boolean;
        description "Local Branch";
      }

      leaf is-local-interface {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "Local Interface";
      }

      leaf role-egress {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "Role Egress";
      }

      leaf forwarding-peek {
        type boolean;
        description "Peek is enabled";
      }

      leaf make-before-break-enabled {
        type boolean;
        description "MBB feature is enabled";
      }

      leaf mo-frr-enabled {
        type boolean;
        description
          "MoFRR feature is enabled";
      }

      leaf recursive-fec-enabled {
        type boolean;
        description
          "Recursive FEC is enabled";
      }

      leaf trace-enabled {
        type boolean;
        description
          "Trace filter is enabled";
      }

      leaf forward-recursive {
        type boolean;
        description
          "Recursive Forwarding is enabled";
      }

      leaf peer-change-delay {
        type int32;
        units "millisecond";
        description
          "Neighbor change delay in milli-seconds";
      }

      leaf encode-branch-id {
        type uint32;
        description
          "Recursive FEC Encode LSM ID";
      }

      leaf decode-branch-id {
        type uint32;
        description
          "Recursive FEC Decode LSM ID";
      }

      leaf upstream-neigbbor-count {
        type uint32;
        description
          "Upstream MLDP neighbor count";
      }

      leaf downstream-branch-count {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "Downstream branch count";
      }

      list upstream-neighbor {
        description "Upstream neighbor List";
        uses MLDP-ACEL-BAG;
      }  // list upstream-neighbor

      list branch {
        description "Branch List";
        uses MLDP-BRANCH-BAG;
      }  // list branch
    }  // grouping MLDP-DATABASE-BAG

    grouping MLDP-BINDING-PATH-BAG {
      description
        "MLDP Binding path information";
      leaf lsmid {
        type uint32;
        description
          "LSM ID of the paths in this LSP binding";
      }

      leaf acel-type {
        type boolean;
        description
          "Binding is Accepting Element";
      }

      leaf branch-type {
        type boolean;
        description "Binding is a branch";
      }

      leaf acel-active {
        type boolean;
        description "This ACEL is active";
      }

      leaf branch-owner-type {
        type uint32;
        description "Which type of branch";
      }

      leaf local-label {
        type uint32;
        description
          "Local label allocated for this binding";
      }

      leaf remote-label {
        type uint32;
        description
          "Remote label assigned to this binding";
      }

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

      leaf rpf-id {
        type uint32;
        description "RPF Identifier";
      }

      leaf interface-name {
        type string {
          length "0..65";
        }
        description "Interface name";
      }
    }  // grouping MLDP-BINDING-PATH-BAG

    grouping MLDP-BINDING-DB-OPQ-BAG {
      description
        "MLDP Binding Opaque information";
      leaf tree-type {
        type uint32;
        description "Tree Type";
      }

      leaf lsmid {
        type uint32;
        description
          "LSM ID of the paths in this LSP binding";
      }

      leaf root-address {
        type inet:ipv4-address;
        description "Root address";
      }

      leaf opaque-decoded-string {
        type string {
          length "0..255";
        }
        description
          "Opaque value decoded string";
      }
    }  // grouping MLDP-BINDING-DB-OPQ-BAG

    grouping MLDP-BINDING-LSP-BAG {
      description
        "MLDP Binding LSP information";
      leaf binding-id {
        type uint32;
        description
          "ID used for this binding";
      }

      leaf num-paths {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint32;
        description
          "Number of paths in this LSP binding";
      }

      list opaque {
        description "FEC Opaque List";
        uses MLDP-BINDING-DB-OPQ-BAG;
      }  // list opaque

      list binding-path {
        description "Path List";
        uses MLDP-BINDING-PATH-BAG;
      }  // list binding-path
    }  // grouping MLDP-BINDING-LSP-BAG

    grouping MLDP-MFI-PATH-BAG {
      description "MFI Label Rewrite Path";
      leaf mpls-label {
        type uint32;
        description "Remote Label";
      }

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

      leaf interface-name {
        type string {
          length "0..65";
        }
        description "Interface name";
      }

      leaf out-info-flags {
        type uint32;
        description "Outinfo flags";
      }

      leaf role {
        type uint32;
        description "Role";
      }
    }  // grouping MLDP-MFI-PATH-BAG

    grouping MLDP-MFI-RW-BAG {
      description
        "MLDP MFI Forwarding Information";
      leaf mpls-local-label {
        type uint32;
        description "Local Label";
      }

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

      leaf head-lsm-id {
        type uint32;
        description "Head LSM ID";
      }

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

      leaf rpf-id {
        type uint32;
        description "RPF Identifier";
      }

      leaf interface-name {
        type string {
          length "0..65";
        }
        description
          "LSP Virtual interface name";
      }

      list forwarding-path {
        description "Path List";
        uses MLDP-MFI-PATH-BAG;
      }  // list forwarding-path
    }  // grouping MLDP-MFI-RW-BAG

    grouping MLDP-STATUS-BAG {
      description "MLDP Status Information";
      leaf mldp-active {
        type boolean;
        description
          "MLDP has been activated";
      }

      leaf mldp-running {
        type boolean;
        description "MLDP is running";
      }

      leaf mldp-ready {
        type boolean;
        description "MLDP is ready";
      }

      leaf mldp-rib-connection-status {
        type boolean;
        description
          "MLDP RIB connection status";
      }

      leaf mldp-rib-connection-open {
        type boolean;
        description
          "MLDP RIB connection open";
      }

      leaf log-internal {
        type boolean;
        description
          "Logging internal is enabled";
      }

      leaf log-notifications {
        type boolean;
        description
          "Logging notifications is enabled";
      }

      leaf label-release-delay {
        type uint32;
        units "millisecond";
        description
          "Label release delay in milli-seconds";
      }

      leaf lsm-id-delay {
        type uint32;
        units "millisecond";
        description
          "LSM ID scan delay in milli-seconds";
      }
    }  // grouping MLDP-STATUS-BAG
  }  // submodule Cisco-IOS-XR-mpls-ldp-mldp-oper-sub1