module Cisco-IOS-XR-mpls-oam-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-mpls-oam-oper";

    prefix mpls-oam-oper;

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

    include Cisco-IOS-XR-mpls-oam-oper-sub2 {
      revision-date "2019-04-05";
    }
    include Cisco-IOS-XR-mpls-oam-oper-sub1 {
      revision-date "2019-04-05";
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
Customer Service

Postal: 170 West Tasman Drive
San Jose, CA 95134

Tel: +1 800 553-NETS

E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
for Cisco IOS-XR mpls-oam package operational data.

This module contains definitions
for the following management objects:
  mpls-oam: MPLS OAM operational data

Copyright (c) 2013-2019 by Cisco Systems, Inc.
All rights reserved.";

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

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

    semver:module-version "1.0.1";

    container mpls-oam {
      config false;
      description
        "MPLS OAM operational data";
      container interface {
        description
          "MPLS OAM interface operational data";
        container briefs {
          description
            "MPLS OAM interface detail data";
          list brief {
            key "interface-name";
            description
              "MPLS OAM interface operational data";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface name";
            }

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

            leaf state {
              type Lspv-bag-interface-state;
              description "Interface state";
            }

            leaf mtu {
              type uint32;
              description "Interface MTU";
            }

            leaf prefix-length {
              type uint32;
              description
                "Prefix length (IPv4)";
            }

            leaf prefix-length-v6 {
              type uint32;
              description
                "Prefix length (IPv6)";
            }

            leaf primary-address {
              type inet:ipv4-address;
              description
                "Primary interface address (IPv4)";
            }

            leaf primary-address-v6 {
              type inet:ipv6-address;
              description
                "Primary interface address (IPv6)";
            }
          }  // list brief
        }  // container briefs

        container details {
          description
            "MPLS OAM interface detail data";
          list detail {
            key "interface-name";
            description
              "MPLS OAM interface operational data";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface name";
            }

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

              leaf state {
                type Lspv-bag-interface-state;
                description
                  "Interface state";
              }

              leaf mtu {
                type uint32;
                description "Interface MTU";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Prefix length (IPv4)";
              }

              leaf prefix-length-v6 {
                type uint32;
                description
                  "Prefix length (IPv6)";
              }

              leaf primary-address {
                type inet:ipv4-address;
                description
                  "Primary interface address (IPv4)";
              }

              leaf primary-address-v6 {
                type inet:ipv6-address;
                description
                  "Primary interface address (IPv6)";
              }
            }  // container interface-brief

            container packet-statistics {
              description
                "Packet statistics";
              container received {
                description
                  "Packet reception counts";
                container received-good-request {
                  description
                    "Received good request";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-good-request

                container received-good-reply {
                  description
                    "Received good reply";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-good-reply

                container received-unknown {
                  description
                    "Received unknown packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-unknown

                container received-error-ip-header {
                  description
                    "IP header error";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-ip-header

                container received-error-udp-header {
                  description
                    "UDP header error";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-udp-header

                container received-error-runt {
                  description "RUNT error";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-runt

                container received-error-queue-full {
                  description
                    "Dropped queue full";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-queue-full

                container received-error-general {
                  description
                    "General error";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-general

                container received-error-no-interface {
                  description
                    "Error no Interfaces";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-no-interface

                container received-error-no-memory {
                  description
                    "Error no memory";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-error-no-memory

                container protect-protocol-received-good-request {
                  description
                    "Protect Protocol Received good request";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container protect-protocol-received-good-request

                container protect-protocol-received-good-reply {
                  description
                    "Protect Protocol Received good reply";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container protect-protocol-received-good-reply

                container received-good-bfd-request {
                  description
                    "Received Reqeust with BFD TLV";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-good-bfd-request

                container received-good-bfd-reply {
                  description
                    "Received Reply with BFD TLV";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container received-good-bfd-reply
              }  // container received

              container sent {
                description
                  "Packet transmit counts";
                container transmit-good {
                  description
                    "Transmit good packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-good

                container transmit-drop {
                  description
                    "Transmit drop packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-drop

                container transmit-bfd-good {
                  description
                    "Transmit good BFD request packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-bfd-good

                container bfd-no-reply {
                  description
                    "No Reply action for echo reqeust of BFD
bootstrap";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container bfd-no-reply
              }  // container sent

              container working-req-sent {
                description
                  "Working Request Packet transmit counts";
                container transmit-good {
                  description
                    "Transmit good packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-good

                container transmit-drop {
                  description
                    "Transmit drop packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-drop

                container transmit-bfd-good {
                  description
                    "Transmit good BFD request packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-bfd-good

                container bfd-no-reply {
                  description
                    "No Reply action for echo reqeust of BFD
bootstrap";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container bfd-no-reply
              }  // container working-req-sent

              container working-rep-sent {
                description
                  "Working Reply Packet transmit counts";
                container transmit-good {
                  description
                    "Transmit good packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-good

                container transmit-drop {
                  description
                    "Transmit drop packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-drop

                container transmit-bfd-good {
                  description
                    "Transmit good BFD request packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-bfd-good

                container bfd-no-reply {
                  description
                    "No Reply action for echo reqeust of BFD
bootstrap";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container bfd-no-reply
              }  // container working-rep-sent

              container protect-req-sent {
                description
                  "Protect Request Packet transmit counts";
                container transmit-good {
                  description
                    "Transmit good packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-good

                container transmit-drop {
                  description
                    "Transmit drop packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-drop

                container transmit-bfd-good {
                  description
                    "Transmit good BFD request packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-bfd-good

                container bfd-no-reply {
                  description
                    "No Reply action for echo reqeust of BFD
bootstrap";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container bfd-no-reply
              }  // container protect-req-sent

              container protect-rep-sent {
                description
                  "Protect Reply Packet transmit counts";
                container transmit-good {
                  description
                    "Transmit good packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-good

                container transmit-drop {
                  description
                    "Transmit drop packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-drop

                container transmit-bfd-good {
                  description
                    "Transmit good BFD request packets";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container transmit-bfd-good

                container bfd-no-reply {
                  description
                    "No Reply action for echo reqeust of BFD
bootstrap";
                  leaf packets {
                    type uint64;
                    description
                      "Packet counter";
                  }

                  leaf bytes {
                    type uint64;
                    units "byte";
                    description
                      "Byte counter";
                  }
                }  // container bfd-no-reply
              }  // container protect-rep-sent
            }  // container packet-statistics
          }  // list detail
        }  // container details
      }  // container interface

      container packet {
        description
          "LSPV packet counters operational data";
        container received {
          description
            "Packet reception counts";
          container received-good-request {
            description
              "Received good request";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-good-request

          container received-good-reply {
            description
              "Received good reply";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-good-reply

          container received-unknown {
            description
              "Received unknown packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-unknown

          container received-error-ip-header {
            description "IP header error";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-ip-header

          container received-error-udp-header {
            description "UDP header error";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-udp-header

          container received-error-runt {
            description "RUNT error";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-runt

          container received-error-queue-full {
            description "Dropped queue full";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-queue-full

          container received-error-general {
            description "General error";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-general

          container received-error-no-interface {
            description
              "Error no Interfaces";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-no-interface

          container received-error-no-memory {
            description "Error no memory";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-error-no-memory

          container protect-protocol-received-good-request {
            description
              "Protect Protocol Received good request";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container protect-protocol-received-good-request

          container protect-protocol-received-good-reply {
            description
              "Protect Protocol Received good reply";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container protect-protocol-received-good-reply

          container received-good-bfd-request {
            description
              "Received Reqeust with BFD TLV";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-good-bfd-request

          container received-good-bfd-reply {
            description
              "Received Reply with BFD TLV";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container received-good-bfd-reply
        }  // container received

        container sent {
          description
            "Packet transmit counts";
          container transmit-good {
            description
              "Transmit good packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-good

          container transmit-drop {
            description
              "Transmit drop packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-drop

          container transmit-bfd-good {
            description
              "Transmit good BFD request packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-bfd-good

          container bfd-no-reply {
            description
              "No Reply action for echo reqeust of BFD
bootstrap";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container bfd-no-reply
        }  // container sent

        container working-req-sent {
          description
            "Working Request Packet transmit counts";
          container transmit-good {
            description
              "Transmit good packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-good

          container transmit-drop {
            description
              "Transmit drop packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-drop

          container transmit-bfd-good {
            description
              "Transmit good BFD request packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-bfd-good

          container bfd-no-reply {
            description
              "No Reply action for echo reqeust of BFD
bootstrap";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container bfd-no-reply
        }  // container working-req-sent

        container working-rep-sent {
          description
            "Working Reply Packet transmit counts";
          container transmit-good {
            description
              "Transmit good packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-good

          container transmit-drop {
            description
              "Transmit drop packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-drop

          container transmit-bfd-good {
            description
              "Transmit good BFD request packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-bfd-good

          container bfd-no-reply {
            description
              "No Reply action for echo reqeust of BFD
bootstrap";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container bfd-no-reply
        }  // container working-rep-sent

        container protect-req-sent {
          description
            "Protect Request Packet transmit counts";
          container transmit-good {
            description
              "Transmit good packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-good

          container transmit-drop {
            description
              "Transmit drop packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-drop

          container transmit-bfd-good {
            description
              "Transmit good BFD request packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-bfd-good

          container bfd-no-reply {
            description
              "No Reply action for echo reqeust of BFD
bootstrap";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container bfd-no-reply
        }  // container protect-req-sent

        container protect-rep-sent {
          description
            "Protect Reply Packet transmit counts";
          container transmit-good {
            description
              "Transmit good packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-good

          container transmit-drop {
            description
              "Transmit drop packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-drop

          container transmit-bfd-good {
            description
              "Transmit good BFD request packets";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container transmit-bfd-good

          container bfd-no-reply {
            description
              "No Reply action for echo reqeust of BFD
bootstrap";
            leaf packets {
              type uint64;
              description "Packet counter";
            }

            leaf bytes {
              type uint64;
              units "byte";
              description "Byte counter";
            }
          }  // container bfd-no-reply
        }  // container protect-rep-sent
      }  // container packet

      container global {
        description
          "LSPV global counters operational data";
        container message-statistics {
          description "Message statistics";
          leaf register-messages {
            type uint32;
            description
              "Message register count";
          }

          leaf unregister-messages {
            type uint32;
            description
              "Message unregister count";
          }

          leaf echo-submit-messages {
            type uint32;
            description
              "Message echo submit count";
          }

          leaf echo-cancel-messages {
            type uint32;
            description
              "Message echo cancel count";
          }

          leaf get-result-messages {
            type uint32;
            description
              "Message get results count";
          }

          leaf get-config-messages {
            type uint32;
            description
              "Message get configiuration count";
          }

          leaf get-response-messages {
            type uint32;
            description
              "Message get response count";
          }

          leaf property-response-messages {
            type uint32;
            description
              "Message property response count";
          }

          leaf property-request-messages {
            type uint32;
            description
              "Message property request count";
          }

          leaf property-block-messages {
            type uint32;
            description
              "Message property block count";
          }

          leaf thread-request-messages {
            type uint32;
            description
              "Message thread request count";
          }
        }  // container message-statistics

        container collaborator-statistics {
          description
            "Collaborator statistics";
          container collaborator-i-parm {
            description
              "Collaborator IPARM counts";
            leaf ups {
              type uint32;
              description
                "Collaborator up counter";
            }

            leaf downs {
              type uint32;
              description
                "Collaborator down counter";
            }
          }  // container collaborator-i-parm

          container collaborator-im {
            description
              "Collaborator IM counts";
            leaf ups {
              type uint32;
              description
                "Collaborator up counter";
            }

            leaf downs {
              type uint32;
              description
                "Collaborator down counter";
            }
          }  // container collaborator-im

          container collaborator-net-io {
            description
              "Collaborator NetIO counts";
            leaf ups {
              type uint32;
              description
                "Collaborator up counter";
            }

            leaf downs {
              type uint32;
              description
                "Collaborator down counter";
            }
          }  // container collaborator-net-io

          container collaborator-rib {
            description
              "Collaborator RIB counts";
            leaf ups {
              type uint32;
              description
                "Collaborator up counter";
            }

            leaf downs {
              type uint32;
              description
                "Collaborator down counter";
            }
          }  // container collaborator-rib
        }  // container collaborator-statistics

        leaf total-clients {
          type uint32;
          description "Number of clients";
        }
      }  // container global

      container dpm {
        description
          "MPLS OAM DPM operational data";
        container adjacency-summary {
          description
            "LSPV DPM adjacency summary operational data";
          leaf adj-db-size {
            type uint32;
            description
              "Size of Adjacency DB";
          }

          leaf dpm-eligible-intfs {
            type uint32;
            description
              "Number of DPM allowed interfaces";
          }

          leaf err-intfs {
            type uint32;
            description
              "Number of Interfaces with Errors";
          }

          leaf validation-start-time {
            type uint64;
            description
              "Validation Start Time";
          }

          leaf validation-end-time {
            type uint64;
            description
              "Validation End Time";
          }
        }  // container adjacency-summary

        container prefixes {
          description
            "MPLS OAM DPM prefix operational data";
          list prefix {
            key "prefix";
            description
              "MPLS OAM DPM prefix operational data";
            leaf prefix {
              type inet:ip-prefix;
              description "The IP Prefix";
            }

            container prefix-xr {
              xr:event-telemetry "Subscribe Telemetry Event";
              description "Prefix";
              container prefix {
                description "Prefix";
                leaf af-name {
                  type Lspv-dpm-addr;
                  description "AFName";
                }

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

                leaf ipv6-prefix {
                  when "../af-name = 'ipv6'" {
                    description
                      "../AFName = 'IPv6'";
                  }
                  type Static-ipv6-address;
                  description "IPv6 prefix";
                }
              }  // container prefix

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

            leaf pfx-sid {
              xr:event-telemetry "Subscribe Telemetry Event";
              type uint32;
              description "Prefix SID";
            }

            leaf requests-sent {
              type uint32;
              description "Requests Sent";
            }

            leaf requests-rcvd {
              type uint32;
              description "Requests Rcvd";
            }

            leaf errors {
              type uint32;
              description "Errors";
            }

            leaf last-fault-time {
              type uint64;
              description "Last Fault Time";
            }

            leaf status {
              type Lspv-dpm-pfx-validation-status;
              description "Status";
            }

            list upstream-adj {
              description
                "Upstream Adjacency";
              leaf af-name {
                type Lspv-dpm-addr;
                description "AFName";
              }

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

              leaf ipv6-prefix {
                when "../af-name = 'ipv6'" {
                  description
                    "../AFName = 'IPv6'";
                }
                type Static-ipv6-address;
                description "IPv6 prefix";
              }
            }  // list upstream-adj

            list downstream-adj-info {
              description
                "Downstream Adjacency Info";
              container next-hop {
                description "NextHop";
                leaf af-name {
                  type Lspv-dpm-addr;
                  description "AFName";
                }

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

                leaf ipv6-prefix {
                  when "../af-name = 'ipv6'" {
                    description
                      "../AFName = 'IPv6'";
                  }
                  type Static-ipv6-address;
                  description "IPv6 prefix";
                }
              }  // container next-hop

              leaf requests-sent {
                type uint32;
                description "Requests Sent";
              }

              leaf errors {
                type uint32;
                description "Errors";
              }

              leaf last-fault-time {
                type uint64;
                description
                  "Last Fault Time";
              }

              leaf status {
                type Lspv-dpm-pfx-validation-status;
                description "Status";
              }

              leaf stale {
                type boolean;
                description "Stale";
              }
            }  // list downstream-adj-info
          }  // list prefix
        }  // container prefixes

        container counters {
          description
            "LSPV DPM counters operational data";
          leaf requests-sent {
            type uint32;
            description "Requests Last Sent";
          }

          leaf requests-last-pending {
            type uint32;
            description
              "Requests Last Pending";
          }

          leaf requests-last-returned {
            type uint32;
            description
              "Requests Last Returned";
          }

          leaf requests-unsent {
            type uint32;
            description "Requests Unsent";
          }

          leaf requests-retry-unsent {
            type uint32;
            description
              "Requests Retry Unsent";
          }

          leaf requests-pending {
            type uint32;
            description "Requests Pending";
          }
        }  // container counters

        container prefix-faults {
          description
            "MPLS OAM DPM prefix fault operational data";
          list prefix-fault {
            description
              "MPLS OAM DPM prefix fault operational data";
            leaf prefix {
              type inet:ip-prefix;
              description "The IP Prefix";
            }

            leaf downstream-address {
              type inet:ip-address-no-zone;
              description
                "Downstream IP Address";
            }

            leaf upstream-address {
              type inet:ip-address-no-zone;
              description
                "Upstream IP Address";
            }

            container prefix-xr {
              description "Prefix";
              container prefix {
                description "Prefix";
                leaf af-name {
                  type Lspv-dpm-addr;
                  description "AFName";
                }

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

                leaf ipv6-prefix {
                  when "../af-name = 'ipv6'" {
                    description
                      "../AFName = 'IPv6'";
                  }
                  type Static-ipv6-address;
                  description "IPv6 prefix";
                }
              }  // container prefix

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

            container downlink-fault {
              xr:event-telemetry "Subscribe Telemetry Event";
              description
                "Downlink associated with the fault";
              leaf af-name {
                type Lspv-dpm-addr;
                description "AFName";
              }

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

              leaf ipv6-prefix {
                when "../af-name = 'ipv6'" {
                  description
                    "../AFName = 'IPv6'";
                }
                type Static-ipv6-address;
                description "IPv6 prefix";
              }
            }  // container downlink-fault

            container uplink-fault {
              xr:event-telemetry "Subscribe Telemetry Event";
              description
                "Uplink associated with the fault";
              leaf af-name {
                type Lspv-dpm-addr;
                description "AFName";
              }

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

              leaf ipv6-prefix {
                when "../af-name = 'ipv6'" {
                  description
                    "../AFName = 'IPv6'";
                }
                type Static-ipv6-address;
                description "IPv6 prefix";
              }
            }  // container uplink-fault

            leaf prefix-sid {
              type uint32;
              description "Prefix SID";
            }

            leaf error-code {
              xr:event-telemetry "Subscribe Telemetry Event";
              type Lspv-dpm-fault-code;
              description "DPM Error code";
            }
          }  // list prefix-fault
        }  // container prefix-faults

        container adjacency-summary-last {
          description
            "LSPV last DPM run adjacency summary operational
data";
          leaf adj-db-size {
            type uint32;
            description
              "Size of Adjacency DB";
          }

          leaf dpm-eligible-intfs {
            type uint32;
            description
              "Number of DPM allowed interfaces";
          }

          leaf err-intfs {
            type uint32;
            description
              "Number of Interfaces with Errors";
          }

          leaf validation-start-time {
            type uint64;
            description
              "Validation Start Time";
          }

          leaf validation-end-time {
            type uint64;
            description
              "Validation End Time";
          }
        }  // container adjacency-summary-last

        container summary {
          description
            "LSPV DPM summary operational data";
          leaf v4rib-reg {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Registration to IPv4 RIB";
          }

          leaf v4rib-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Connection to IPv4 RIB";
          }

          leaf sysdb-reg {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Registration to SYSDB";
          }

          leaf sysdb-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Connection to SYSDB";
          }

          leaf im-reg {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description "Registration to IM";
          }

          leaf im-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description "Connection to IM";
          }

          leaf lspv-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description "Connection to LSPV";
          }

          leaf num-of-adj {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Adjacencies in DB";
          }

          leaf validated-adjs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Validated Adjacencies";
          }

          leaf dpm-eligible-intfs {
            type uint32;
            description
              "Number of DPM allowed interfaces";
          }

          leaf error-adjs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Errored Adjacencies";
          }

          leaf num-of-pfx {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Prefixes in DB";
          }

          leaf validated-pfxs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Validated Prefixes";
          }

          leaf error-pfxs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "Errored Prefixes";
          }

          leaf total-requests {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "Total Requests";
          }

          leaf total-responses {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "Total Responses";
          }

          leaf total-prop-req {
            type uint32;
            description
              "Total Property Requests";
          }

          leaf total-prop-errs {
            type uint32;
            description
              "Total Property Errors";
          }

          leaf total-prop-resp {
            type uint32;
            description
              "Total Property Responses";
          }

          leaf dpm-interval {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "DPM Run Interval";
          }

          leaf dpm-packets-per-second {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            units "packet/s";
            description
              "DPM Packets Per Second";
          }

          leaf total-retries {
            type uint32;
            description "Total Retries";
          }

          leaf validation-complete {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "DPM Validation Complete";
          }

          leaf last-dpm-run-time {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint64;
            description
              "Last DPM interation time in nanosec";
          }

          leaf last-dpm-fault-time {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint64;
            description
              "Last DPM fault time in nanosec";
          }

          leaf last-dpm-fault-time-ever {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint64;
            description
              "Last Ever DPM fault time in nanosec";
          }
        }  // container summary

        container adjacency-faults {
          description
            "MPLS OAM DPM adjacency operational data";
          list adjacency-fault {
            description
              "MPLS OAM DPM adjcency fault operational data";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface name";
            }

            leaf local-label-id {
              type uint32 {
                range "16..1048575";
              }
              description "Local Label";
            }

            container ip {
              xr:event-telemetry "Subscribe Telemetry Event";
              description "IP Address";
              leaf af-name {
                type Lspv-dpm-addr;
                description "AFName";
              }

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

              leaf ipv6-prefix {
                when "../af-name = 'ipv6'" {
                  description
                    "../AFName = 'IPv6'";
                }
                type Static-ipv6-address;
                description "IPv6 prefix";
              }
            }  // container ip

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

            leaf igp {
              xr:event-telemetry "Subscribe Telemetry Event";
              type Lspv-dpm-igp;
              description "IGP";
            }

            leaf local-adj-sid {
              xr:event-telemetry "Subscribe Telemetry Event";
              type uint32;
              description "Local Adj SID";
            }

            leaf error-code {
              xr:event-telemetry "Subscribe Telemetry Event";
              type Lspv-dpm-fault-code;
              description "DPM Error code";
            }
          }  // list adjacency-fault
        }  // container adjacency-faults

        container adjacencies {
          description
            "MPLS OAM DPM adjacency operational data";
          list adjacency {
            key "interface-name";
            description
              "MPLS OAM DPM adjcency operational data";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface name";
            }

            container local-address {
              description "Local Address";
              leaf af-name {
                type Lspv-dpm-addr;
                description "AFName";
              }

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

              leaf ipv6-prefix {
                when "../af-name = 'ipv6'" {
                  description
                    "../AFName = 'IPv6'";
                }
                type Static-ipv6-address;
                description "IPv6 prefix";
              }
            }  // container local-address

            container remote-address {
              description "Remote Address";
              leaf af-name {
                type Lspv-dpm-addr;
                description "AFName";
              }

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

              leaf ipv6-prefix {
                when "../af-name = 'ipv6'" {
                  description
                    "../AFName = 'IPv6'";
                }
                type Static-ipv6-address;
                description "IPv6 prefix";
              }
            }  // container remote-address

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

            leaf local-interface-id {
              type uint32;
              description
                "Local Interface Id";
            }

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

            leaf remote-interface-id {
              type uint32;
              description
                "Remote Interface Id";
            }

            leaf unprotected-remote-label {
              type uint32;
              description
                "Unprotected Remote Label";
            }

            leaf valid-adj {
              type uint32;
              description
                "Valid Adjacencies";
            }

            leaf total-adj {
              type uint32;
              description
                "Total Adjacencies";
            }

            leaf is-isis {
              type boolean;
              description "ISIS enabled";
            }

            leaf is-ipv4 {
              type boolean;
              description "IPv4 enabled";
            }

            leaf is-excluded {
              type boolean;
              description
                "Skipped for the current run";
            }

            leaf last-fault-time {
              type uint64;
              description "Last Fault Time";
            }

            list local-adj {
              description
                "Local Adjacencies";
              leaf local-label {
                type uint32;
                description "Label";
              }

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

              leaf protected {
                type boolean;
                description "Protected";
              }

              leaf static-adj {
                type boolean;
                description "Static Adj";
              }

              leaf group {
                type boolean;
                description "Group";
              }

              leaf isis-l1 {
                type boolean;
                description "ISIS Level 1";
              }

              leaf isis-l2 {
                type boolean;
                description "ISIS Level 2";
              }

              leaf success {
                type boolean;
                description "Sucess";
              }
            }  // list local-adj

            list remote-adj {
              description
                "Remote Adjacencies";
              leaf local-label {
                type uint32;
                description "Label";
              }

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

              leaf protected {
                type boolean;
                description "Protected";
              }

              leaf static-adj {
                type boolean;
                description "Static Adj";
              }

              leaf group {
                type boolean;
                description "Group";
              }

              leaf isis-l1 {
                type boolean;
                description "ISIS Level 1";
              }

              leaf isis-l2 {
                type boolean;
                description "ISIS Level 2";
              }

              leaf success {
                type boolean;
                description "Sucess";
              }
            }  // list remote-adj
          }  // list adjacency
        }  // container adjacencies

        container prefix-summary {
          description
            "LSPV DPM prefix summary operational data";
          leaf pfx-db-size {
            type uint32;
            description "Size of Prefix DB";
          }

          leaf validated-prefixes {
            type uint32;
            description
              "Number of Validated Prefixes";
          }

          leaf requests-sent {
            type uint32;
            description
              "Number of Echo Requests Sent";
          }

          leaf requests-rcvd {
            type uint32;
            description
              "Number of Echo Requests Received";
          }

          leaf validation-errors {
            type uint32;
            description "Validation Errors";
          }

          leaf validation-start-time {
            type uint64;
            description "DPM Start Time";
          }

          leaf validation-end-time {
            type uint64;
            description "DPM End Time";
          }
        }  // container prefix-summary

        container prefix-summary-last {
          description
            "LSPV last DPM run prefix summary operational
data";
          leaf pfx-db-size {
            type uint32;
            description "Size of Prefix DB";
          }

          leaf validated-prefixes {
            type uint32;
            description
              "Number of Validated Prefixes";
          }

          leaf requests-sent {
            type uint32;
            description
              "Number of Echo Requests Sent";
          }

          leaf requests-rcvd {
            type uint32;
            description
              "Number of Echo Requests Received";
          }

          leaf validation-errors {
            type uint32;
            description "Validation Errors";
          }

          leaf validation-start-time {
            type uint64;
            description "DPM Start Time";
          }

          leaf validation-end-time {
            type uint64;
            description "DPM End Time";
          }
        }  // container prefix-summary-last

        container summary-last {
          description
            "LSPV last DPM run summary operational data";
          leaf v4rib-reg {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Registration to IPv4 RIB";
          }

          leaf v4rib-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Connection to IPv4 RIB";
          }

          leaf sysdb-reg {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Registration to SYSDB";
          }

          leaf sysdb-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "Connection to SYSDB";
          }

          leaf im-reg {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description "Registration to IM";
          }

          leaf im-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description "Connection to IM";
          }

          leaf lspv-con {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description "Connection to LSPV";
          }

          leaf num-of-adj {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Adjacencies in DB";
          }

          leaf validated-adjs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Validated Adjacencies";
          }

          leaf dpm-eligible-intfs {
            type uint32;
            description
              "Number of DPM allowed interfaces";
          }

          leaf error-adjs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Errored Adjacencies";
          }

          leaf num-of-pfx {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Prefixes in DB";
          }

          leaf validated-pfxs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Number of Validated Prefixes";
          }

          leaf error-pfxs {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "Errored Prefixes";
          }

          leaf total-requests {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "Total Requests";
          }

          leaf total-responses {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "Total Responses";
          }

          leaf total-prop-req {
            type uint32;
            description
              "Total Property Requests";
          }

          leaf total-prop-errs {
            type uint32;
            description
              "Total Property Errors";
          }

          leaf total-prop-resp {
            type uint32;
            description
              "Total Property Responses";
          }

          leaf dpm-interval {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description "DPM Run Interval";
          }

          leaf dpm-packets-per-second {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            units "packet/s";
            description
              "DPM Packets Per Second";
          }

          leaf total-retries {
            type uint32;
            description "Total Retries";
          }

          leaf validation-complete {
            xr:event-telemetry "Subscribe Telemetry Event";
            type boolean;
            description
              "DPM Validation Complete";
          }

          leaf last-dpm-run-time {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint64;
            description
              "Last DPM interation time in nanosec";
          }

          leaf last-dpm-fault-time {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint64;
            description
              "Last DPM fault time in nanosec";
          }

          leaf last-dpm-fault-time-ever {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint64;
            description
              "Last Ever DPM fault time in nanosec";
          }
        }  // container summary-last
      }  // container dpm
    }  // container mpls-oam
  }  // module Cisco-IOS-XR-mpls-oam-oper