submodule Cisco-IOS-XR-ethernet-cfm-oper-sub2 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-ethernet-cfm-oper {
        prefix
          Cisco-IOS-XR-ethernet-cfm-oper;
    }

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

    include Cisco-IOS-XR-ethernet-cfm-oper-sub3 {
      revision-date "2020-10-07";
    }

    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 ethernet-cfm package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-10-07" {
      description
        "Added the Link Loss Forwarding feature.";
    }

    revision "2020-07-07" {
      description
        "Added SLA summary information.";
    }

    revision "2019-10-02" {
      description
        "Bandwidth notification addition";
    }

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

    revision "2018-12-20" {
      description
        "Bandwidth notification class and type name update.";
    }

    revision "2017-10-06" {
      description
        "Traceroute transaction ID changed from int to uint.";
    }

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

    semver:module-version "1.3.0";
    semver:module-version "1.2.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Cfm-pm-addl-intf-status {
      type enumeration {
        enum "unknown" {
          value 0;
          description
            "Additional interface status unknown";
        }
        enum "administratively-down" {
          value 1;
          description
            "Interface is explicitly shutdown in
           configuration";
        }
        enum "remote-excessive-errors" {
          value 2;
          description
            "Remote interface has exceeded its 802.3 Link
           OAM error threshold";
        }
        enum "local-excessive-errors" {
          value 3;
          description
            "Local interface has exceeded its 802.3 Link OAM
           error threshold";
        }
      }
      description
        "Additional interface status";
    }

    typedef Cfm-pm-intf-status {
      type enumeration {
        enum "interface-status-up" {
          value 1;
          description "Interface is up";
        }
        enum "interface-status-down" {
          value 2;
          description "Interface is down";
        }
        enum "interface-status-testing" {
          value 3;
          description
            "Interface is in testing mode";
        }
        enum "interface-status-unknown" {
          value 4;
          description
            "Unknown interface status";
        }
        enum "interface-status-dormant" {
          value 5;
          description "Interface is dormant";
        }
        enum "interface-status-not-present" {
          value 6;
          description
            "Interface status not found";
        }
        enum
          "interface-status-lower-layer-down" {
          value 7;
          description "Lower layer is down";
        }
      }
      description "Interface status";
    }

    typedef Cfm-pm-port-status {
      type enumeration {
        enum "port-status-blocked" {
          value 1;
          description "Port is STP blocked";
        }
        enum "port-status-up" {
          value 2;
          description "Port is up";
        }
        enum "port-status-unknown" {
          value 3;
          description "Unknown port status";
        }
      }
      description "Port status";
    }

    typedef Cfm-pm-rmep-state {
      type enumeration {
        enum "peer-mep-idle" {
          value 1;
          description
            "Momentary state during reset";
        }
        enum "peer-mep-start" {
          value 2;
          description
            "Loss timer not expired since reset, but no
           valid CCM received";
        }
        enum "peer-mep-failed" {
          value 3;
          description
            "Loss timer has expired";
        }
        enum "peer-mep-ok" {
          value 4;
          description
            "Loss timer has not expired since last valid CCM";
        }
      }
      description
        "State of the Peer MEP state machine";
    }

    typedef Cfm-pm-rmep-xc-state {
      type enumeration {
        enum "cross-check-ok" {
          value 0;
          description "Cross-check OK";
        }
        enum "cross-check-missing" {
          value 1;
          description
            "No CCMs received within loss time from peer MEP";
        }
        enum "cross-check-extra" {
          value 2;
          description
            "CCMs received from peer MEP not marked for
           cross-check";
        }
      }
      description
        "Cross-check state of a peer MEP";
    }

    typedef Cfm-pm-ais-receive {
      type enumeration {
        enum "receive-none" {
          value 0;
          description "No signal received";
        }
        enum "receive-ais" {
          value 1;
          description
            "Receiving AIS messages";
        }
        enum "receive-lck" {
          value 2;
          description
            "Receiving LCK messages";
        }
        enum "receive-direct" {
          value 3;
          description
            "Receiving AIS directly from another MEP on the
           same interface";
        }
      }
      description
        "Enumeration of how the MEP is receiving the
       signal, directly or via AIS or LCK messages.";
    }

    typedef Cfm-pm-ais-transmit {
      type enumeration {
        enum "transmit-none" {
          value 0;
          description "AIS not transmitted";
        }
        enum "transmit-ais" {
          value 1;
          description
            "AIS transmitted via MIP";
        }
        enum "transmit-ais-direct" {
          value 2;
          description
            "AIS signal passed directly to a higher MEP";
        }
      }
      description
        "Enumeration of how the MEP is transmitting AIS,
       via a MIP or directly to a higher MEP";
    }

    typedef Cfm-pm-mep-defect {
      type enumeration {
        enum "defect-none" {
          value 0;
          description "No defect reported";
        }
        enum "defect-rdi-ccm" {
          value 1;
          description
            "Some Peer MEP's CCM has the RDI bit set";
        }
        enum "defect-ma-cstatus" {
          value 2;
          description
            "A Peer MEP port or interface status error has
           been reported";
        }
        enum "defect-remote-ccm" {
          value 3;
          description
            "Not receiving valid CCMs from at least one Peer
           MEP";
        }
        enum "defect-error-ccm" {
          value 4;
          description
            "Currently receiving invalid CCMs from at least
           one Peer MEP";
        }
        enum "defect-cross-connect-ccm" {
          value 5;
          description
            "Currently receiving CCMs from an incorrect
           service (MA)";
        }
      }
      description
        "Defects that can be reported by a MEP";
    }

    typedef Cfm-pm-mep-fng-state {
      type enumeration {
        enum "fng-reset" {
          value 1;
          description "FNG in reset state";
        }
        enum "fng-defect" {
          value 2;
          description
            "FNG has detected but not yet reported a defect";
        }
        enum "fng-report-defect" {
          value 3;
          description
            "FNG is in the process of reporting a defect";
        }
        enum "fng-defect-reported" {
          value 4;
          description
            "FNG has reported a defect";
        }
        enum "fng-defect-clearing" {
          value 5;
          description
            "No defect present, but the reset timer has not
           yet expired";
        }
      }
      description
        "Fault Notification Generation state machine
       states";
    }

    typedef Cfm-pm-elr-egress-action {
      type enumeration {
        enum "elr-egress-ok" {
          value 1;
          description "OK";
        }
        enum "elr-egress-down" {
          value 2;
          description "Down";
        }
        enum "elr-egress-blocked" {
          value 3;
          description "STP Blocked";
        }
        enum "elr-egress-vid" {
          value 4;
          description "VID Blocked";
        }
        enum "elr-egress-mac" {
          value 255;
          description "MAC Pruned";
        }
      }
      description "ELR Egress action";
    }

    typedef Cfm-pm-elr-ingress-action {
      type enumeration {
        enum "elr-ingress-ok" {
          value 1;
          description "OK";
        }
        enum "elr-ingress-down" {
          value 2;
          description "Down";
        }
        enum "elr-ingress-blocked" {
          value 3;
          description "STP Blocked";
        }
        enum "elr-ingress-vid" {
          value 4;
          description "VID Blocked";
        }
      }
      description "ELR Ingress action";
    }

    typedef Cfm-pm-elr-relay-action {
      type enumeration {
        enum "elr-relay-hit" {
          value 1;
          description "Target Hit";
        }
        enum "elr-relay-fdb" {
          value 2;
          description "Filtering database";
        }
        enum "elr-relay-flood" {
          value 3;
          description "Flood forwarded";
        }
        enum "elr-relay-drop" {
          value 4;
          description "Dropped";
        }
      }
      description "ELR relay action";
    }

    typedef Cfm-pm-last-hop-fmt {
      type enumeration {
        enum "last-hop-none" {
          value 0;
          description
            "No last hop identifier";
        }
        enum "last-hop-host-name" {
          value 1;
          description
            "Last hop identifier is a hostname";
        }
        enum "last-hop-egress-id" {
          value 2;
          description
            "Last hop identifier is an egress ID";
        }
      }
      description
        "Last hop identifier format";
    }

    typedef Cfm-pm-egress-action {
      type enumeration {
        enum "egress-ok" {
          value 1;
          description "OK";
        }
        enum "egress-down" {
          value 2;
          description "Down";
        }
        enum "egress-blocked" {
          value 3;
          description "STP Blocked";
        }
        enum "egress-vid" {
          value 4;
          description "VID Blocked";
        }
      }
      description "Egress action";
    }

    typedef Cfm-pm-port-id-fmt {
      type enumeration {
        enum "port-id-interface-alias" {
          value 1;
          description
            "Port ID is an interface alias";
        }
        enum "port-id-port-component" {
          value 2;
          description
            "Port ID is a component name";
        }
        enum "port-id-mac-address" {
          value 3;
          description
            "Port ID is a MAC address";
        }
        enum "port-id-network-address" {
          value 4;
          description
            "Port ID is a network address";
        }
        enum "port-id-interface-name" {
          value 5;
          description
            "Port ID is an interface name";
        }
        enum "port-id-agent-circuit-id" {
          value 6;
          description
            "Port ID is an agent name";
        }
        enum "port-id-local" {
          value 7;
          description
            "Port ID is a local name";
        }
        enum "port-id-unknown" {
          value 8;
          description
            "Port ID format unknown";
        }
      }
      description "Port ID format";
    }

    typedef Cfm-pm-ingress-action {
      type enumeration {
        enum "ingress-ok" {
          value 1;
          description "OK";
        }
        enum "ingress-down" {
          value 2;
          description "Down";
        }
        enum "ingress-blocked" {
          value 3;
          description "STP Blocked";
        }
        enum "ingress-vid" {
          value 4;
          description "VID Blocked";
        }
      }
      description "Ingress action";
    }

    typedef Cfm-pm-id-fmt {
      type enumeration {
        enum "id-format-is-string" {
          value 0;
          description
            "ID format is a string";
        }
        enum "id-format-is-mac-address" {
          value 1;
          description
            "ID format is a MAC address";
        }
        enum "id-format-is-raw-hex" {
          value 2;
          description "ID format is raw hex";
        }
      }
      description "ID format";
    }

    typedef Cfm-pm-chassis-id-fmt {
      type enumeration {
        enum "chassis-id-chassis-component" {
          value 1;
          description
            "Chassis ID is a component name";
        }
        enum "chassis-id-interface-alias" {
          value 2;
          description
            "Chassis ID is an interface alias";
        }
        enum "chassis-id-port-component" {
          value 3;
          description
            "Chassis ID is a port component name";
        }
        enum "chassis-id-mac-address" {
          value 4;
          description
            "Chassis ID is a MAC address";
        }
        enum "chassis-id-network-address" {
          value 5;
          description
            "Chassis ID is a network address";
        }
        enum "chassis-id-interface-name" {
          value 6;
          description
            "Chassis ID is an interface name";
        }
        enum "chassis-id-local" {
          value 7;
          description
            "Chassis ID is a local name";
        }
        enum "chassis-id-unknown-type" {
          value 8;
          description
            "Unknown Chassis ID type";
        }
      }
      description "Chassis ID type";
    }

    typedef Cfm-pm-relay-action {
      type enumeration {
        enum "relay-hit" {
          value 1;
          description "Target Hit";
        }
        enum "relay-fdb" {
          value 2;
          description "Filtering database";
        }
        enum "relay-mpdb" {
          value 3;
          description
            "CCM Learning database";
        }
      }
      description "LTR relay action";
    }

    typedef Cfm-pm-elm-reply-filter {
      type enumeration {
        enum "reply-filter-not-present" {
          value 0;
          description
            "Reply Filter not present";
        }
        enum "reply-filter-default" {
          value 1;
          description
            "Reply from ports which are not MAC-pruned,
           VID-pruned, or STP-blocked";
        }
        enum "reply-filter-vlan-topology" {
          value 2;
          description
            "Reply from ports which are not VID-pruned or
           STP-blocked";
        }
        enum "reply-filter-spanning-tree" {
          value 3;
          description
            "Reply from ports which are not STP-blocked";
        }
        enum "reply-filter-all-ports" {
          value 4;
          description "Reply from all ports";
        }
      }
      description
        "Reply filter used for Exploratory Linktrace
       operations";
    }

    typedef Cfm-pm-elt-delay-model {
      type enumeration {
        enum "delay-model-invalid" {
          value 0;
          description
            "Not a valid delay model";
        }
        enum "delay-model-logarithmic" {
          value 1;
          description
            "Reply using logarithmic delay model";
        }
        enum "delay-model-constant" {
          value 2;
          description
            "Reply using constant delay model";
        }
      }
      description
        "Delay model used for Exploratory Linktrace
       operations";
    }

    typedef Cfm-pm-lt-mode {
      type enumeration {
        enum "cfm-pm-lt-mode-basic" {
          value 1;
          description
            "Basic IEEE 802.1ag Linktrace";
        }
        enum "cfm-pm-lt-mode-exploratory" {
          value 2;
          description
            "Cisco Exploratory Linktrace";
        }
      }
      description
        "Type of Linktrace operation";
    }

    typedef Cfm-pm-pkt-action {
      type enumeration {
        enum "packet-processed" {
          value 0;
          description
            "Packet processed successfully";
        }
        enum "packet-forwarded" {
          value 1;
          description "Packet forwarded";
        }
        enum "unknown-opcode" {
          value 2;
          description
            "Packet dropped at a MEP due to unknown opcode";
        }
        enum "filter-level" {
          value 3;
          description
            "Packet dropped due to level/opcode filtering at
           a MEP";
        }
        enum "filter-blocked" {
          value 4;
          description
            "Packet dropped because interface is STP blocked";
        }
        enum "filter-local-mac" {
          value 5;
          description
            "Packet dropped due to local destination MAC";
        }
        enum "malformed-ccm-size" {
          value 6;
          description
            "CCM too short or too long";
        }
        enum "malformed-ccm-mep-id" {
          value 7;
          description "Invalid MEP-ID";
        }
        enum "malformed-too-short" {
          value 8;
          description "Packet too short";
        }
        enum
          "malformed-destination-mac-unicast" {
          value 9;
          description
            "Destination MAC address does not match
           interface";
        }
        enum
          "malformed-destination-mac-multicast" {
          value 10;
          description
            "Invalid multicast destination MAC address";
        }
        enum "malformed-tlv-offset" {
          value 11;
          description
            "TLV offset too short or beyond the end of the
           packet";
        }
        enum "malformed-lbm-source-mac" {
          value 12;
          description
            "Invalid source MAC address for LBM";
        }
        enum "malformed-ltr-relay-action" {
          value 13;
          description
            "Unknown LTR relay action";
        }
        enum "malformed-ltr-reply-tlv" {
          value 14;
          description
            "LTR has neither reply-ingress or reply-egress";
        }
        enum "malformed-lt-origin" {
          value 15;
          description
            "Invalid Linktrace Message origin MAC address";
        }
        enum "malformed-ltm-target" {
          value 16;
          description
            "Invalid LTM target MAC address";
        }
        enum "malformed-source-mac" {
          value 17;
          description
            "Invalid source MAC address";
        }
        enum "malformed-header-too-short" {
          value 18;
          description
            "Packet too short for CFM header";
        }
        enum "malformed-tlv-header-overrun" {
          value 19;
          description
            "TLV header extends beyond the end of the packet";
        }
        enum "malformed-tlv-overrun" {
          value 20;
          description
            "TLV extends beyond the end of the packet";
        }
        enum "malformed-duplicate-sender-id" {
          value 21;
          description
            "Multiple Sender-ID TLVs found";
        }
        enum
          "malformed-duplicate-port-status" {
          value 22;
          description
            "Multiple Port-status TLVs found";
        }
        enum
          "malformed-duplicate-interface-status" {
          value 23;
          description
            "Multiple Interface-state TLVs found";
        }
        enum "malformed-wrong-tlv" {
          value 24;
          description
            "Invalid TLV for this type of packet found";
        }
        enum "malformed-duplicate-data" {
          value 25;
          description
            "Multiple Data TLVs found";
        }
        enum
          "malformed-duplicate-ltr-egress-id" {
          value 26;
          description
            "Multiple LTR-Egress-ID TLVs found";
        }
        enum
          "malformed-duplicate-reply-ingress" {
          value 27;
          description
            "Multiple Reply-ingress TLVs found";
        }
        enum
          "malformed-duplicate-reply-egress" {
          value 28;
          description
            "Multiple Reply-egress TLVs found";
        }
        enum
          "malformed-duplicate-ltm-egress-id" {
          value 29;
          description
            "Multiple LTM-Egress-ID TLVs found";
        }
        enum "malformed-sender-id-size" {
          value 30;
          description
            "Sender-ID TLV is too short";
        }
        enum "malformed-chassis-id-size" {
          value 31;
          description
            "Sender-ID TLV is too short to contain the
           Chassis ID";
        }
        enum
          "malformed-mgmt-address-domain-size" {
          value 32;
          description
            "Sender-ID TLV is too short to contain the
           management address domain";
        }
        enum "malformed-mgmt-address-size" {
          value 33;
          description
            "Sender-ID TLV is too short to contain the
           management address";
        }
        enum "malformed-port-status-size" {
          value 34;
          description
            "Port-status TLV is too short";
        }
        enum "malformed-port-status" {
          value 35;
          description
            "Invalid Port status value";
        }
        enum
          "malformed-interface-status-size" {
          value 36;
          description
            "Interface-status TLV is too short";
        }
        enum "malformed-interface-status" {
          value 37;
          description
            "Invalid Interface status value";
        }
        enum
          "malformed-organization-specific-tlv-size" {
          value 38;
          description
            "Organization-specific TLV is too short";
        }
        enum "malformed-duplicate-mep-name" {
          value 39;
          description
            "Multiple MEP-name TLVs found";
        }
        enum
          "malformed-duplicate-additional-interface-status" {
          value 40;
          description
            "Multiple additional-interface-status TLVs found";
        }
        enum "malformed-ltr-egress-id-size" {
          value 41;
          description
            "LTR-Egress-ID TLV is too short";
        }
        enum "malformed-reply-ingress-size" {
          value 42;
          description
            "Reply-ingress TLV is too short";
        }
        enum "malformed-ingress-action" {
          value 43;
          description
            "Invalid ingress-action value";
        }
        enum "malformed-reply-ingress-mac" {
          value 44;
          description
            "Reply-ingress TLV has invalid MAC address";
        }
        enum
          "malformed-ingress-port-length-size" {
          value 45;
          description
            "Reply-ingress TLV is too short to contain the
           Port ID type";
        }
        enum
          "malformed-ingress-port-id-length" {
          value 46;
          description
            "Reply-ingress TLV has a zero Port ID length";
        }
        enum
          "malformed-ingress-port-id-size" {
          value 47;
          description
            "Reply-ingress TLV is too short to contain the
           Port ID";
        }
        enum "malformed-reply-egress-size" {
          value 48;
          description
            "Reply-egress TLV is too short";
        }
        enum "malformed-egress-action" {
          value 49;
          description
            "Invalid egress-action value";
        }
        enum "malformed-reply-egress-mac" {
          value 50;
          description
            "Reply-egress TLV has invalid MAC address";
        }
        enum
          "malformed-egress-port-length-size" {
          value 51;
          description
            "Reply-egress TLV is too short to contain the
           Port ID type";
        }
        enum
          "malformed-egress-port-id-length" {
          value 52;
          description
            "Reply-egress TLV has a zero Port ID length";
        }
        enum "malformed-egress-port-id-size" {
          value 53;
          description
            "Reply-egress TLV is too short to contain the
           Port ID";
        }
        enum "malformed-ltm-egress-id-size" {
          value 54;
          description
            "LTM-Egress_ID TLV is too short";
        }
        enum "malformed-mep-name-size" {
          value 55;
          description
            "MEP-name TLV is too short";
        }
        enum
          "malformed-mep-name-name-length" {
          value 56;
          description
            "MEP-name TLV is too short to contain a MEP name";
        }
        enum
          "malformed-additional-interface-status-size" {
          value 57;
          description
            "Additional-interface-status is too short";
        }
        enum
          "malformed-additional-interface-status" {
          value 58;
          description
            "Invalid additional interface status";
        }
        enum "malformed-ccm-interval" {
          value 59;
          description
            "CCM has a zero CCM interval";
        }
        enum
          "malformed-mdid-mac-address-length" {
          value 60;
          description
            "CCM has a MAC-address MDID but the MDID is the
           wrong length";
        }
        enum "malformed-mdid-length" {
          value 61;
          description
            "CCM has an invalid MDID length";
        }
        enum "malformed-sman-length" {
          value 62;
          description
            "CCM has an invalid Short MA Name length";
        }
        enum "malformed-sman2-byte-length" {
          value 63;
          description
            "CCM has a VID or 16-bit Short MA Name but a
           mismatched length";
        }
        enum "malformed-sman-vpn-id-length" {
          value 64;
          description
            "CCM has a VPNID Short MA Name but a mismatched
           length";
        }
        enum "malformed-elr-no-reply-tlv" {
          value 65;
          description
            "ELR has no ELR Reply TLVs";
        }
        enum
          "malformed-separate-elr-reply-egress" {
          value 66;
          description
            "ELR Reply Egress TLVs not all adjacent";
        }
        enum
          "malformed-dcm-destination-multicast" {
          value 67;
          description
            "DCM has a multicast destination MAC";
        }
        enum "malformed-dcm-embed-length" {
          value 68;
          description
            "DCM is too short to contain an Embedded PDU";
        }
        enum "malformed-dcm-embed-level" {
          value 69;
          description
            "DCM Embedded PDU level does not match DCM level";
        }
        enum "malformed-dcm-embed-version" {
          value 70;
          description
            "DCM Embedded PDU version does not match DCM
           version";
        }
        enum "malformed-elr-relay-action" {
          value 71;
          description
            "Unknown ELR relay action";
        }
        enum "malformed-elr-tt-ls" {
          value 73;
          description
            "Reply Ingress TTL is not one greater than Reply
           Egress TTL";
        }
        enum "malformed-elr-ttl-ingress" {
          value 74;
          description
            "Reply Ingress TTL present without ELR Reply
           Ingress TLV";
        }
        enum "malformed-elr-ttl-egress" {
          value 75;
          description
            "Reply Egress TTL present without ELR Reply
           Egress TLV";
        }
        enum
          "malformed-elm-destination-unicast" {
          value 76;
          description
            "ELM Destination MAC must not be unicast";
        }
        enum "malformed-elm-egress-id" {
          value 77;
          description
            "ELM has no LTM Egress ID TLV";
        }
        enum "malformed-dcm-embed-oui" {
          value 78;
          description
            "Embedded DCM OUI unrecognized";
        }
        enum "malformed-dcm-embed-opcode" {
          value 79;
          description
            "Embedded DCM Opcode is not ELM";
        }
        enum "malformed-elm-constant-zero" {
          value 80;
          description
            "ELM Constant Factor is zero";
        }
        enum "malformed-elr-timeout-zero" {
          value 81;
          description
            "ELR Next-Hop Timeout is zero";
        }
        enum "malformed-duplicate-test" {
          value 82;
          description
            "Multiple Test TLVs found";
        }
        enum "malformed-dmm-source-mac" {
          value 83;
          description
            "Invalid source MAC address for DMM";
        }
        enum "malformed-test-size" {
          value 84;
          description
            "Test TLV is too short";
        }
        enum "malformed-dmr-time-stamps" {
          value 85;
          description
            "DMR has exactly one of its Rxf and Txb
           timestamps unspecified";
        }
        enum "malformed-dm-time-stamp-fmt" {
          value 86;
          description
            "The format of one or more timestamps is invalid";
        }
        enum "malformed-ais-interval" {
          value 87;
          description
            "AIS/LCK has invalid interval value (not 1
           second or 1 minute)";
        }
        enum "filter-interface-down" {
          value 88;
          description
            "Packet dropped due to interface being down";
        }
        enum "filter-forward-standby" {
          value 89;
          description
            "Packet dropped - not forwarded because
           interface is in standby mode";
        }
        enum
          "malformed-sman-icc-based-length" {
          value 90;
          description
            "CCM has an ICC-based format Short MA Name but a
           mismatched length";
        }
        enum "filter-foward-issu-secondary" {
          value 120;
          description
            "Packet dropped - not forwarded in secondary HA
           role";
        }
        enum "filter-response-standby" {
          value 121;
          description
            "Packet dropped - not responded to because
           interface is in standby mode";
        }
        enum
          "filter-response-issu-secondary" {
          value 122;
          description
            "Packet dropped - not responded to in secondary
           HA role";
        }
      }
      description
        "Action taken for received packet";
    }

    typedef Cfm-pm-bnm-packet {
      type enumeration {
        enum "bnm-packet-type-bnm" {
          value 0;
          description "BNM";
        }
        enum "bnm-packet-type-bwvsm" {
          value 1;
          description "Cisco BW-VSM";
        }
      }
      description "BNM packet types";
    }

    typedef Cfm-pm-bnm-link-state {
      type enumeration {
        enum "bnm-link-state-ok" {
          value 1;
          description "Link state OK";
        }
        enum "bnm-link-state-degraded" {
          value 2;
          description "Link state degraded";
        }
      }
      description
        "Enumeration of BNM link states";
    }

    grouping CFM-PM-REMOTE-MEP-STATS {
      description "Peer MEP statistics";
      container last-ccm-received-time {
        description
          "Elapsed time since last CCM received";
        uses CFM-PM-TIMESTAMP;
      }  // container last-ccm-received-time

      leaf ccms-received {
        type uint64;
        description
          "Number of CCMs received";
      }

      leaf ccms-wrong-level {
        type uint64;
        description
          "Number of CCMs received with an invalid level";
      }

      leaf ccms-invalid-maid {
        type uint64;
        description
          "Number of CCMs received with an invalid MAID";
      }

      leaf ccms-invalid-interval {
        type uint64;
        description
          "Number of CCMs received with an invalid interval";
      }

      leaf ccms-invalid-source-mac-address {
        type uint64;
        description
          "Number of CCMs received with an invalid source
         MAC address";
      }

      leaf ccms-our-mep-id {
        type uint64;
        description
          "Number of CCMs received with our MEP ID";
      }

      leaf ccms-rdi {
        type uint64;
        description
          "Number of CCMs received with the Remote Defect
         Indication bit set";
      }

      leaf ccms-out-of-sequence {
        type uint64;
        description
          "Number of CCMs received out-of-sequence";
      }

      leaf last-ccm-sequence-number {
        type uint32;
        description
          "Sequence number of last CCM received";
      }
    }  // grouping CFM-PM-REMOTE-MEP-STATS

    grouping CFM-PM-MEP-NAME {
      description "MEP name";
      leaf name {
        type string;
        description "MEP name";
      }
    }  // grouping CFM-PM-MEP-NAME

    grouping CFM-PM-CCM-HDR-V2 {
      description "CCM frame header";
      container mdid {
        description "MDID";
        uses CFM-BAG-MDID-V2;
      }  // container mdid

      container short-ma-name {
        description "Short MA Name";
        uses CFM-BAG-SMAN-V2;
      }  // container short-ma-name

      leaf level {
        type Cfm-bag-md-level;
        description "MD level";
      }

      leaf version {
        type uint8;
        description "Version";
      }

      leaf interval {
        type Cfm-bag-ccm-interval;
        description "CCM interval";
      }

      leaf rdi {
        type boolean;
        description
          "Remote defect indicated";
      }

      leaf sequence-number {
        type uint32;
        description "CCM sequence number";
      }

      leaf mep-id {
        type uint16;
        description "MEP ID";
      }

      leaf mdid-format {
        type uint8;
        description "MDID Format";
      }

      leaf short-ma-name-format {
        type uint8;
        description "Short MA Name format";
      }
    }  // grouping CFM-PM-CCM-HDR-V2

    grouping CFM-PM-CCM-V2 {
      description
        "Continuity check message (CCM)";
      container header {
        description "Frame header";
        uses CFM-PM-CCM-HDR-V2;
      }  // container header

      container sender-id {
        description "Sender ID TLV";
        uses CFM-PM-SENDER-ID;
      }  // container sender-id

      container mep-name {
        description "MEP name";
        uses CFM-PM-MEP-NAME;
      }  // container mep-name

      leaf port-status {
        type Cfm-pm-port-status;
        description "Port status";
      }

      leaf interface-status {
        type Cfm-pm-intf-status;
        description "Interface status";
      }

      leaf additional-interface-status {
        type Cfm-pm-addl-intf-status;
        description
          "Additional interface status";
      }

      leaf raw-data {
        type yang:hex-string;
        description "Undecoded frame";
      }

      list organization-specific-tlv {
        description
          "Organizational-specific TLVs";
        uses CFM-PM-ORG-SPEC-TLV;
      }  // list organization-specific-tlv

      list unknown-tlv {
        description "Unknown TLVs";
        uses CFM-PM-UNKNOWN-TLV;
      }  // list unknown-tlv
    }  // grouping CFM-PM-CCM-V2

    grouping CFM-PM-REMOTE-MEP-V2 {
      description
        "Peer maintenance endpoint (MEP)";
      container error-state {
        description "Error state";
        uses CFM-PM-RMEP-ERR-STATE;
      }  // container error-state

      container last-up-down-time {
        description
          "Elapsed time since peer MEP became active or
         timed out";
        uses CFM-PM-TIMESTAMP;
      }  // container last-up-down-time

      container last-ccm-received {
        description
          "Last CCM received from the peer MEP";
        uses CFM-PM-CCM-V2;
      }  // container last-ccm-received

      container statistics {
        description "Peer MEP statistics";
        uses CFM-PM-REMOTE-MEP-STATS;
      }  // container statistics

      leaf mep-id {
        type uint16;
        description "MEP ID";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }

      leaf cross-check-state {
        type Cfm-pm-rmep-xc-state;
        description "Cross-check state";
      }

      leaf peer-mep-state {
        type Cfm-pm-rmep-state;
        description
          "State of the peer MEP state machine";
      }

      leaf ccm-offload {
        type Cfm-bag-ccm-offload;
        description
          "Offload status of received CCM handling";
      }
    }  // grouping CFM-PM-REMOTE-MEP-V2

    grouping CFM-PM-REMOTE-MEPS-V2-BAG {
      description "Peer MEPs table entry";
      container peer-mep {
        description "Peer MEP";
        uses CFM-PM-REMOTE-MEP-V2;
      }  // container peer-mep

      leaf domain-xr {
        type string;
        description
          "Maintenance domain name";
      }

      leaf service-xr {
        type string;
        description "Service name";
      }

      leaf level {
        type Cfm-bag-md-level;
        description "Maintenance level";
      }

      leaf mep-id {
        type uint16;
        description "MEP ID";
      }

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

      leaf mep-direction {
        type Cfm-bag-direction;
        description "MEP facing direction";
      }

      leaf standby {
        type boolean;
        description
          "The local MEP is on an interface in standby mode";
      }
    }  // grouping CFM-PM-REMOTE-MEPS-V2-BAG

    grouping CFM-PM-MEP-AIS-STATS {
      description
        "Local MEP AIS information";
      container sending-start {
        description
          "Time elapsed since AIS sending started";
        uses CFM-PM-TIMESTAMP;
      }  // container sending-start

      container receiving-start {
        description
          "Time elapsed since AIS receiving started";
        uses CFM-PM-TIMESTAMP;
      }  // container receiving-start

      leaf level {
        type Cfm-bag-md-level;
        description "AIS transmission level";
      }

      leaf interval {
        type Cfm-bag-ais-interval;
        description
          "AIS transmission interval";
      }

      leaf sending-ais {
        type Cfm-pm-ais-transmit;
        description
          "Details of how AIS is being transmitted";
      }

      leaf receiving-ais {
        type Cfm-pm-ais-receive;
        description
          "Details of how the signal is being received";
      }

      leaf last-interval {
        type Cfm-bag-ais-interval;
        description
          "The interval of the last received AIS packet";
      }

      leaf last-mac-address {
        type Mac-address;
        description
          "Source MAC address of the last received AIS
         packet";
      }
    }  // grouping CFM-PM-MEP-AIS-STATS

    grouping CFM-PM-MEP-STATS {
      description "Local MEP statistics";
      leaf ccms-sent {
        type uint64;
        description "Number of CCMs sent";
      }

      leaf ccms-received {
        type uint64;
        description
          "Number of CCMs received";
      }

      leaf ccms-out-of-sequence {
        type uint64;
        description
          "Number of CCMs received out-of-sequence";
      }

      leaf ccms-discarded {
        type uint64;
        description
          "Number of CCMs discarded because maximum MEPs
         limit was reached";
      }

      leaf lb-ms-sent {
        type uint64;
        description "Number of LBMs sent";
      }

      leaf lb-rs-sent {
        type uint64;
        description "Number of LBRs sent";
      }

      leaf lb-rs-received {
        type uint64;
        description
          "Number of LBRs received";
      }

      leaf lb-rs-out-of-sequence {
        type uint64;
        description
          "Number of LBRs received out-of-sequence";
      }

      leaf lb-rs-bad-data {
        type uint64;
        description
          "Number of LBRs received with non-matching
         user-specified data";
      }

      leaf lb-ms-received {
        type uint64;
        description
          "Number of LBMs received";
      }

      leaf lt-rs-received-unexpected {
        type uint64;
        description
          "Number of unexpected LTRs received";
      }

      leaf ai-ss-sent {
        type uint64;
        description
          "Number of AIS messages sent";
      }

      leaf ai-ss-received {
        type uint64;
        description
          "Number of AIS messages received";
      }

      leaf lc-ks-received {
        type uint64;
        description
          "Number of LCK messages received";
      }

      leaf dm-ms-sent {
        type uint64;
        description
          "Number of DMM messages sent";
      }

      leaf dm-ms-received {
        type uint64;
        description
          "Number of DMM messages received";
      }

      leaf dm-rs-sent {
        type uint64;
        description
          "Number of DMR messages sent";
      }

      leaf dm-rs-received {
        type uint64;
        description
          "Number of DMR messages received";
      }

      leaf sl-ms-sent {
        type uint64;
        description
          "Number of SLM messages sent";
      }

      leaf sl-ms-received {
        type uint64;
        description
          "Number of SLM messages received";
      }

      leaf sl-rs-sent {
        type uint64;
        description
          "Number of SLR messages sent";
      }

      leaf sl-rs-received {
        type uint64;
        description
          "Number of SLR messages received";
      }

      leaf lm-ms-sent {
        type uint64;
        description
          "Number of LMM messages sent";
      }

      leaf lm-ms-received {
        type uint64;
        description
          "Number of LMM messages received";
      }

      leaf lm-rs-sent {
        type uint64;
        description
          "Number of LMR messages sent";
      }

      leaf lm-rs-received {
        type uint64;
        description
          "Number of LMR messages received";
      }

      leaf bn-ms-received {
        type uint64;
        description
          "Number of BNM messages received";
      }

      leaf bn-ms-discarded {
        type uint64;
        description
          "Number of BNM messages discarded";
      }

      leaf ll-ms-sent {
        type uint64;
        description
          "Number of LLM messages sent";
      }

      leaf ll-ms-received {
        type uint64;
        description
          "Number of LLM messages received";
      }

      leaf ll-rs-sent {
        type uint64;
        description
          "Number of LLR messages sent";
      }

      leaf ll-rs-received {
        type uint64;
        description
          "Number of LLR messages received";
      }
    }  // grouping CFM-PM-MEP-STATS

    grouping CFM-PM-MEP-STATS-BAG {
      description "Local MEP table entry";
      container statistics {
        description "MEP statistics";
        uses CFM-PM-MEP-STATS;
      }  // container statistics

      container ais-statistics {
        description "MEP AIS statistics";
        uses CFM-PM-MEP-AIS-STATS;
      }  // container ais-statistics

      container defects {
        description
          "Defects detected from peer MEPs";
        uses CFM-PM-DEFECTS;
      }  // container defects

      leaf domain-xr {
        type string;
        description
          "Maintenance domain name";
      }

      leaf service-xr {
        type string;
        description "Service name";
      }

      leaf level {
        type Cfm-bag-md-level;
        description "Maintenance level";
      }

      leaf mep-id-xr {
        type uint16;
        description "MEP ID";
      }

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

      leaf interface-state {
        type string;
        description "IM Interface state";
      }

      leaf interworking-state {
        type Cfm-bag-iw-state;
        description
          "Interface interworking state";
      }

      leaf stp-state {
        type Cfm-bag-stp-state;
        description "STP state";
      }

      leaf mep-direction {
        type Cfm-bag-direction;
        description "MEP facing direction";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }

      leaf peer-meps-detected {
        type uint32;
        description
          "Number of peer MEPs detected";
      }

      leaf peer-meps-with-errors-detected {
        type uint32;
        description
          "Number of peer MEPs detected with errors";
      }

      leaf remote-defect {
        type boolean;
        description
          "Remote defect indicated";
      }

      leaf fault-notification-state {
        type Cfm-pm-mep-fng-state;
        description
          "Fault Notification Generation state";
      }

      leaf ccm-generation-enabled {
        type boolean;
        description "CCM generation enabled";
      }

      leaf ccm-interval {
        type Cfm-bag-ccm-interval;
        description
          "The interval between CCMs";
      }

      leaf ccm-offload {
        type Cfm-bag-ccm-offload;
        description
          "Offload status of CCM processing";
      }

      leaf highest-defect {
        type Cfm-pm-mep-defect;
        description
          "Highest-priority defect present since last FNG
         reset";
      }

      leaf rdi-defect {
        type boolean;
        description
          "A peer MEP RDI defect has been reported";
      }

      leaf mac-status-defect {
        type boolean;
        description
          "A peer MEP port or interface status error has
         been reported";
      }

      leaf peer-mep-ccm-defect {
        type boolean;
        description
          "A peer MEP CCM error has been reported";
      }

      leaf error-ccm-defect {
        type boolean;
        description
          "A CCM error has been reported";
      }

      leaf cross-connect-ccm-defect {
        type boolean;
        description
          "A cross-connect CCM error has been reported";
      }

      leaf next-lbm-id {
        type uint32;
        description
          "Next Transaction ID to be sent in a Loopback
         Message";
      }

      leaf next-ltm-id {
        type uint32;
        description
          "Next Transaction ID to be sent in a Linktrace
         Message";
      }

      leaf cos {
        type uint8;
        description
          "CoS bits the MEP will use for sent packets, if
         configured";
      }

      leaf efd-triggered {
        type boolean;
        description
          "EFD triggered on the interface";
      }

      leaf standby {
        type boolean;
        description
          "The local MEP is on an interface in standby mode";
      }

      leaf hairpin {
        type boolean;
        description
          "MEP is on a sub-interface in the same
         bridge-domain and on the same trunk interface as
         another sub-interface";
      }

      leaf defects-ignored {
        type boolean;
        description
          "Defects present but ignored due to 'report
         defects' configuration";
      }

      leaf tx-disable-triggered {
        type boolean;
        description "TX disable triggered";
      }

      leaf restore-timer {
        type uint32;
        description "Restore timer";
      }

      leaf receiving-csf {
        type boolean;
        description "Receiving CSF";
      }

      leaf sending-csf {
        type boolean;
        description "Sending CSF";
      }

      leaf csf-interval {
        type uint32;
        description "CSF packet interval";
      }

      leaf cos-bits {
        type uint32;
        description "CoS bits";
      }

      leaf csf-started {
        type uint32;
        description
          "Time when CSF packets were first sent";
      }

      leaf received-csf-interval {
        type Cfm-bag-ccm-interval;
        description
          "Time at which we are receiving CSF packets";
      }

      leaf csf-received {
        type uint32;
        description
          "Time when CSF packets were first received";
      }
    }  // grouping CFM-PM-MEP-STATS-BAG

    grouping CFM-PM-ELR-REPLY-EGRESS {
      description "ELR Reply egress TLV";
      container last-egress-id {
        description "Last Egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container last-egress-id

      container next-egress-id {
        description "Next Egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container next-egress-id

      container port-id {
        description "Port ID";
        uses CFM-PM-PORT-ID;
      }  // container port-id

      leaf action {
        type Cfm-pm-elr-egress-action;
        description "Reply egress action";
      }

      leaf mac-address {
        type Mac-address;
        description
          "MAC address of egress interface";
      }
    }  // grouping CFM-PM-ELR-REPLY-EGRESS

    grouping CFM-PM-ELR-REPLY-INGRESS {
      description "ELR Reply ingress TLV";
      container last-egress-id {
        description "Last egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container last-egress-id

      container next-egress-id {
        description "Next egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container next-egress-id

      container port-id {
        description "Port ID";
        uses CFM-PM-PORT-ID;
      }  // container port-id

      leaf action {
        type Cfm-pm-elr-ingress-action;
        description
          "ELR Reply ingress action";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }
    }  // grouping CFM-PM-ELR-REPLY-INGRESS

    grouping CFM-PM-ELR-HDR {
      description "ELR frame header";
      leaf level {
        type Cfm-bag-md-level;
        description "MD level";
      }

      leaf version {
        type uint8;
        description "Version";
      }

      leaf forwarded {
        type boolean;
        description "ELR was forwarded";
      }

      leaf terminal-mep {
        type boolean;
        description "Terminal MEP reached";
      }

      leaf reply-filter-unknown {
        type boolean;
        description
          "Reply Filter unrecognized";
      }

      leaf transaction-id {
        type uint32;
        description "Transaction ID";
      }

      leaf ttl {
        type uint8;
        description "TTL";
      }

      leaf relay-action {
        type Cfm-pm-elr-relay-action;
        description "Relay action";
      }

      leaf next-hop-timeout {
        type uint32;
        units "second";
        description
          "Next Hop Timeout, in seconds";
      }

      leaf delay-model {
        type Cfm-pm-elt-delay-model;
        description "Delay Model";
      }
    }  // grouping CFM-PM-ELR-HDR

    grouping CFM-PM-ELR {
      description
        "Exploratory Linktrace Reply (ELR) message ";
      container header {
        description "Frame header";
        uses CFM-PM-ELR-HDR;
      }  // container header

      container sender-id {
        description "Sender ID TLV";
        uses CFM-PM-SENDER-ID;
      }  // container sender-id

      container reply-ingress {
        description "Reply ingress TLV";
        uses CFM-PM-ELR-REPLY-INGRESS;
      }  // container reply-ingress

      container reply-egress {
        description "Reply egress TLV";
        uses CFM-PM-ELR-REPLY-EGRESS;
      }  // container reply-egress

      container last-hop {
        description "Last hop ID";
        uses CFM-PM-LAST-HOP;
      }  // container last-hop

      leaf raw-data {
        type yang:hex-string;
        description "Undecoded frame";
      }

      list organization-specific-tlv {
        description
          "Organizational-specific TLVs";
        uses CFM-PM-ORG-SPEC-TLV;
      }  // list organization-specific-tlv

      list unknown-tlv {
        description "Unknown TLVs";
        uses CFM-PM-UNKNOWN-TLV;
      }  // list unknown-tlv
    }  // grouping CFM-PM-ELR

    grouping CFM-PM-LAST-HOP {
      description "Last hop type";
      container egress-id {
        when
          "../last-hop-format = 'last-hop-egress-id'" {
          description
            "../LastHopFormat = 'LastHopEgressID'";
        }
        description "Egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container egress-id

      leaf last-hop-format {
        type Cfm-pm-last-hop-fmt;
        description "LastHopFormat";
      }

      leaf host-name {
        when
          "../last-hop-format = 'last-hop-host-name'" {
          description
            "../LastHopFormat = 'LastHopHostname'";
        }
        type Cfm-bag-optional-string;
        description "Hostname";
      }
    }  // grouping CFM-PM-LAST-HOP

    grouping CFM-PM-UNKNOWN-TLV {
      description "Unknown TLV";
      leaf typecode {
        type uint8;
        description "Type code of TLV";
      }

      leaf value {
        type yang:hex-string;
        description "Binary data in TLV";
      }
    }  // grouping CFM-PM-UNKNOWN-TLV

    grouping CFM-PM-ORG-SPEC-TLV {
      description
        "Organizational-specific TLV";
      leaf oui {
        type yang:hex-string;
        description
          "Organizationally-unique ID";
      }

      leaf subtype {
        type uint8;
        description "Subtype of TLV";
      }

      leaf value {
        type yang:hex-string;
        description "Binary data in TLV";
      }
    }  // grouping CFM-PM-ORG-SPEC-TLV

    grouping CFM-PM-REPLY-EGRESS {
      description "Reply egress TLV";
      container port-id {
        description "Port ID";
        uses CFM-PM-PORT-ID;
      }  // container port-id

      leaf action {
        type Cfm-pm-egress-action;
        description "Reply egress action";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }
    }  // grouping CFM-PM-REPLY-EGRESS

    grouping CFM-PM-PORT-ID-VAL {
      description "Port ID Value";
      leaf port-id-format {
        type Cfm-pm-id-fmt;
        description "PortIDFormat";
      }

      leaf port-id-string {
        when
          "../port-id-format = 'id-format-is-string'" {
          description
            "../PortIDFormat = 'IDFormatIsString'";
        }
        type Cfm-bag-optional-string;
        description "Port ID String";
      }

      leaf port-id-mac {
        when
          "../port-id-format = 'id-format-is-mac-address'" {
          description
            "../PortIDFormat = 'IDFormatIsMACAddress'";
        }
        type Mac-address;
        description "Port ID MAC Address";
      }

      leaf port-id-raw {
        when
          "../port-id-format != 'id-format-is-string' and ../port-id-format != 'id-format-is-mac-address'" {
          description
            "../PortIDFormat != 'IDFormatIsString' and .
           ./PortIDFormat != 'IDFormatIsMACAddress'";
        }
        type Cfm-bag-optional-hex-data;
        description "Raw Port ID";
      }
    }  // grouping CFM-PM-PORT-ID-VAL

    grouping CFM-PM-PORT-ID {
      description "Port ID";
      container port-id-value {
        description "Port ID (Current)";
        uses CFM-PM-PORT-ID-VAL;
      }  // container port-id-value

      leaf port-id-type {
        type Cfm-pm-port-id-fmt;
        description "Port ID type";
      }

      leaf port-id-type-value {
        type uint8;
        description "Port ID type value";
      }

      leaf port-id {
        type yang:hex-string;
        description "Port ID (Deprecated)";
      }
    }  // grouping CFM-PM-PORT-ID

    grouping CFM-PM-REPLY-INGRESS {
      description "Reply ingress TLV";
      container port-id {
        description "Port ID";
        uses CFM-PM-PORT-ID;
      }  // container port-id

      leaf action {
        type Cfm-pm-ingress-action;
        description "Reply ingress action";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }
    }  // grouping CFM-PM-REPLY-INGRESS

    grouping CFM-PM-EGRESS-ID-TYPE {
      description "Egress ID";
      leaf unique-id {
        type uint16;
        description "Unique ID";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }
    }  // grouping CFM-PM-EGRESS-ID-TYPE

    grouping CFM-PM-LTR-EGRESS-ID {
      description "LTR Egress ID TLV";
      container last-egress-id {
        description "Last egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container last-egress-id

      container next-egress-id {
        description "Next egress ID";
        uses CFM-PM-EGRESS-ID-TYPE;
      }  // container next-egress-id
    }  // grouping CFM-PM-LTR-EGRESS-ID

    grouping CFM-PM-CHASSIS-ID-VAL {
      description "Chassis ID Value";
      leaf chassis-id-format {
        type Cfm-pm-id-fmt;
        description "ChassisIDFormat";
      }

      leaf chassis-id-string {
        when
          "../chassis-id-format = 'id-format-is-string'" {
          description
            "../ChassisIDFormat = 'IDFormatIsString'";
        }
        type Cfm-bag-optional-string;
        description "Chassis ID String";
      }

      leaf chassis-id-mac {
        when
          "../chassis-id-format = 'id-format-is-mac-address'" {
          description
            "../ChassisIDFormat = 'IDFormatIsMACAddress'";
        }
        type Mac-address;
        description "Chassis ID MAC Address";
      }

      leaf chassis-id-raw {
        when
          "../chassis-id-format != 'id-format-is-string' and ../chassis-id-format != 'id-format-is-mac-address'" {
          description
            "../ChassisIDFormat != 'IDFormatIsString' and .
           ./ChassisIDFormat != 'IDFormatIsMACAddress'";
        }
        type Cfm-bag-optional-hex-data;
        description "Raw Chassis ID";
      }
    }  // grouping CFM-PM-CHASSIS-ID-VAL

    grouping CFM-PM-CHASSIS-ID {
      description "Chassis ID";
      container chassis-id-value {
        description "Chassis ID (Current)";
        uses CFM-PM-CHASSIS-ID-VAL;
      }  // container chassis-id-value

      leaf chassis-id-type {
        type Cfm-pm-chassis-id-fmt;
        description "Chassis ID Type";
      }

      leaf chassis-id-type-value {
        type uint8;
        description "Chassis ID Type";
      }

      leaf chassis-id {
        type yang:hex-string;
        description
          "Chassis ID (Deprecated)";
      }
    }  // grouping CFM-PM-CHASSIS-ID

    grouping CFM-PM-SENDER-ID {
      description "Sender ID TLV";
      container chassis-id {
        description "Chassis ID";
        uses CFM-PM-CHASSIS-ID;
      }  // container chassis-id

      leaf management-address-domain {
        type yang:hex-string;
        description
          "Management address domain";
      }

      leaf management-address {
        type yang:hex-string;
        description "Management address";
      }
    }  // grouping CFM-PM-SENDER-ID

    grouping CFM-PM-LTR-HDR {
      description "LTR frame header";
      leaf level {
        type Cfm-bag-md-level;
        description "MD level";
      }

      leaf version {
        type uint8;
        description "Version";
      }

      leaf use-fdb-only {
        type boolean;
        description "Use filtering DB only";
      }

      leaf forwarded {
        type boolean;
        description "LTR was forwarded";
      }

      leaf terminal-mep {
        type boolean;
        description "Terminal MEP reached";
      }

      leaf transaction-id {
        type uint32;
        description "Transaction ID";
      }

      leaf ttl {
        type uint8;
        description "TTL";
      }

      leaf relay-action {
        type Cfm-pm-relay-action;
        description "Relay action";
      }
    }  // grouping CFM-PM-LTR-HDR

    grouping CFM-PM-LTR {
      description
        "Linktrace reply (LTR) message ";
      container header {
        description "Frame header";
        uses CFM-PM-LTR-HDR;
      }  // container header

      container sender-id {
        description "Sender ID TLV";
        uses CFM-PM-SENDER-ID;
      }  // container sender-id

      container egress-id {
        description "Egress ID TLV";
        uses CFM-PM-LTR-EGRESS-ID;
      }  // container egress-id

      container reply-ingress {
        description "Reply ingress TLV";
        uses CFM-PM-REPLY-INGRESS;
      }  // container reply-ingress

      container reply-egress {
        description "Reply egress TLV";
        uses CFM-PM-REPLY-EGRESS;
      }  // container reply-egress

      container last-hop {
        description "Last hop ID";
        uses CFM-PM-LAST-HOP;
      }  // container last-hop

      leaf raw-data {
        type yang:hex-string;
        description "Undecoded frame";
      }

      list organization-specific-tlv {
        description
          "Organizational-specific TLVs";
        uses CFM-PM-ORG-SPEC-TLV;
      }  // list organization-specific-tlv

      list unknown-tlv {
        description "Unknown TLVs";
        uses CFM-PM-UNKNOWN-TLV;
      }  // list unknown-tlv
    }  // grouping CFM-PM-LTR

    grouping CFM-PM-MEP-TR-CACHE-BAG {
      description
        "Traceroute cache table entry";
      container traceroute-information {
        description
          "Information about the traceroute operation";
        uses CFM-PM-LT-INFO;
      }  // container traceroute-information

      leaf replies-dropped {
        type uint32;
        description
          "Count of ignored replies for this request";
      }

      list linktrace-reply {
        description
          "Received linktrace replies";
        uses CFM-PM-LTR;
      }  // list linktrace-reply

      list exploratory-linktrace-reply {
        description
          "Received exploratory linktrace replies";
        uses CFM-PM-ELR;
      }  // list exploratory-linktrace-reply
    }  // grouping CFM-PM-MEP-TR-CACHE-BAG

    grouping CFM-PM-LT-OPTS-EXPLORATORY {
      description
        "options for an Exploratory Linktrace";
      leaf delay-model {
        type Cfm-pm-elt-delay-model;
        description
          "Delay model for delay calculations";
      }

      leaf delay-constant-factor {
        type uint32;
        description
          "Constant Factor for delay calculations";
      }

      leaf reply-filter {
        type Cfm-pm-elm-reply-filter;
        description
          "Reply Filtering mode used by responders";
      }
    }  // grouping CFM-PM-LT-OPTS-EXPLORATORY

    grouping CFM-PM-LT-OPTS-BASIC {
      description
        "Options for a basic IEEE 802.1ag Linktrace";
      leaf is-auto {
        type boolean;
        description
          "Traceroute was initiated automatically";
      }

      leaf fdb-only {
        type boolean;
        description
          "Only use the Filtering Database for forwarding
         lookups";
      }
    }  // grouping CFM-PM-LT-OPTS-BASIC

    grouping CFM-PM-LT-OPTS {
      description
        "Options affecting the behavior of the traceroute";
      container basic-options {
        when
          "../mode = 'cfm-pm-lt-mode-basic'" {
          description
            "../Mode = 'CFM_PM_LT_MODE_BASIC'";
        }
        description
          "Options for a basic IEEE 802.1ag Linktrace";
        uses CFM-PM-LT-OPTS-BASIC;
      }  // container basic-options

      container exploratory-options {
        when
          "../mode = 'cfm-pm-lt-mode-exploratory'" {
          description
            "../Mode = 'CFM_PM_LT_MODE_EXPLORATORY'";
        }
        description
          "Options for an Exploratory Linktrace";
        uses CFM-PM-LT-OPTS-EXPLORATORY;
      }  // container exploratory-options

      leaf mode {
        type Cfm-pm-lt-mode;
        description "Mode";
      }
    }  // grouping CFM-PM-LT-OPTS

    grouping CFM-PM-LT-INFO {
      description
        "Information about a traceroute request";
      container options {
        description
          "Options affecting traceroute behavior";
        uses CFM-PM-LT-OPTS;
      }  // container options

      leaf domain {
        type string;
        description
          "Maintenance domain name";
      }

      leaf service {
        type string;
        description "Service name";
      }

      leaf level {
        type Cfm-bag-md-level;
        description "Maintenance level";
      }

      leaf source-mep-id {
        type uint16;
        description "Source MEP ID";
      }

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

      leaf source-mac-address {
        type Mac-address;
        description "Source MAC address";
      }

      leaf target-mac-address {
        type Mac-address;
        description "Target MAC address";
      }

      leaf directed-mac-address {
        type Mac-address;
        description "Directed MAC address";
      }

      leaf target-mep-id {
        type uint16;
        description "Target MEP ID";
      }

      leaf timestamp {
        type uint64;
        units "second";
        description
          "Timestamp of initiation time (seconds)";
      }

      leaf ttl {
        type uint8;
        description "Time to live";
      }

      leaf transaction-id {
        type uint32;
        description "Transaction ID";
      }
    }  // grouping CFM-PM-LT-INFO

    grouping CFM-PM-MEP-INCOMPLETE-TR-BAG {
      description
        "Local MEP incomplete traceroute table entry";
      container traceroute-information {
        description
          "Information about the traceroute operation";
        uses CFM-PM-LT-INFO;
      }  // container traceroute-information

      leaf time-left {
        type uint64;
        units "second";
        description
          "Time (in seconds) before the traceroute
         completes";
      }
    }  // grouping CFM-PM-MEP-INCOMPLETE-TR-BAG

    grouping CFM-PM-CLDB-BAG {
      description
        "Continuity check message learning database table
       entry";
      leaf domain-xr {
        type string;
        description
          "Maintenance domain name";
      }

      leaf level {
        type Cfm-bag-md-level;
        description "Maintenance level";
      }

      leaf service-xr {
        type string;
        description
          "Maintenance association name";
      }

      leaf source-mac-address {
        type Mac-address;
        description "Source MAC address";
      }

      leaf ingress-interface {
        type uint32;
        description
          "The XID of the ingress interface for the CCM";
      }

      leaf stale {
        type boolean;
        description
          "The XID is stale and may have been reused for a
         different interface";
      }

      leaf ingress-interface-string {
        type string;
        description
          "String representation of the Bridge Domain or
         Cross-Connect associated with the ingress XID";
      }
    }  // grouping CFM-PM-CLDB-BAG

    grouping CFM-PM-MALF-PKT-DATA {
      description
        "Structure to hold information about one packet";
      leaf reason {
        type Cfm-pm-pkt-action;
        description
          "Reason for being malformed";
      }

      leaf direction {
        type Cfm-bag-pkt-direction;
        description
          "Direction the packet was travelling in";
      }

      leaf source-mac-address {
        type Mac-address;
        description "Source MAC address";
      }

      leaf dest-mac-address {
        type Mac-address;
        description
          "Destination MAC address";
      }

      leaf timestamp {
        type uint32;
        units "second";
        description
          "Timestamp for the packet in seconds";
      }

      leaf timestamp-msec {
        type uint32;
        description
          "Millisecond resolution for the timestamp";
      }

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

      leaf packet-content {
        type yang:hex-string;
        description "Raw packet content";
      }
    }  // grouping CFM-PM-MALF-PKT-DATA

    grouping CFM-PM-MALF-PKT-IFH-BAG {
      description
        "Array of malformed packets for one interface";
      list malformed-packet-array {
        description "Malformed Packet Array";
        uses CFM-PM-MALF-PKT-DATA;
      }  // list malformed-packet-array
    }  // grouping CFM-PM-MALF-PKT-IFH-BAG

    grouping CFM-PM-EFP-LLF-MEP {
      description
        "Bag for a single MEP on an interface for the LLF
       table";
      container defects {
        description "Defects detected";
        uses CFM-PM-DEFECTS;
      }  // container defects

      leaf mep-id {
        type uint16;
        description "MEP ID";
      }

      leaf restore-timer {
        type uint32;
        description "Restore timer";
      }
    }  // grouping CFM-PM-EFP-LLF-MEP

    grouping CFM-PM-EFP-LLF-BAG {
      description
        "Local interface LLF table entry";
      leaf interface-xr {
        type xr:Interface-name;
        description "Interface";
      }

      leaf interface-state {
        type string;
        description "IM Interface state";
      }

      leaf interworking-state {
        type Cfm-bag-iw-state;
        description
          "Interface interworking state";
      }

      leaf stp-state {
        type Cfm-bag-stp-state;
        description "STP state";
      }

      list meps {
        description
          "List of MEPs on interface";
        uses CFM-PM-EFP-LLF-MEP;
      }  // list meps
    }  // grouping CFM-PM-EFP-LLF-BAG

    grouping CFM-PM-EFP-STATS {
      description "EFP statistics";
      leaf malformed-packets {
        type uint64;
        description
          "Number of malformed packets received at this EFP";
      }

      leaf dropped-packets {
        type uint64;
        description
          "Number of packets dropped at this EFP";
      }

      leaf last-malformed-opcode {
        type Cfm-bag-opcode;
        description
          "Opcode for last malformed packet";
      }

      leaf last-malformed-reason {
        type Cfm-pm-pkt-action;
        description
          "Reason last malformed packet was malformed";
      }
    }  // grouping CFM-PM-EFP-STATS

    grouping CFM-PM-EFP-STATS-BAG {
      description
        "Local interface statistics table entry";
      container statistics {
        description "EFP statistics";
        uses CFM-PM-EFP-STATS;
      }  // container statistics

      leaf interface-xr {
        type xr:Interface-name;
        description "Interface";
      }
    }  // grouping CFM-PM-EFP-STATS-BAG

    grouping CFM-PM-BNM {
      description
        "Last BNM Received details";
      container time-received {
        description
          "Time elapsed since BNM received";
        uses CFM-PM-TIMESTAMP;
      }  // container time-received

      leaf nominal-bandwidth {
        type uint32;
        description "Nominal bandwidth";
      }

      leaf current-bandwidth {
        type uint32;
        description "Current bandwidth";
      }

      leaf interval {
        type Cfm-bag-bnm-interval;
        description "Interval";
      }

      leaf packet-type {
        type Cfm-pm-bnm-packet;
        description "Packet type";
      }
    }  // grouping CFM-PM-BNM

    grouping CFM-PM-BNM-LINK {
      description "BNM Enabled Link";
      container time-in-state {
        description
          "Elapsed time in this state";
        uses CFM-PM-TIMESTAMP;
      }  // container time-in-state

      container last-bnm-received {
        description "Last BNM received";
        uses CFM-PM-BNM;
      }  // container last-bnm-received

      leaf port-id {
        type uint32;
        description "Port ID";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }

      leaf bnm-link-state {
        type Cfm-pm-bnm-link-state;
        description
          "State of the BNM Enabled Link state machine";
      }

      leaf nominal-bandwidth {
        type uint32;
        description "Nominal Bandwidth";
      }

      leaf reported-bandwidth {
        type uint32;
        description "Reported Bandwidth";
      }

      leaf transitions-to-degraded {
        type uint32;
        description
          "Number of transitions into degraded state";
      }

      leaf holdoff-remaining {
        type uint32;
        description
          "Time remaining on hold-off timer";
      }

      leaf wait-to-restore-remaining {
        type uint32;
        description
          "Time remaining on wait-to-restore timer";
      }

      leaf bn-ms-received {
        type uint32;
        description
          "Number of BNMs received";
      }
    }  // grouping CFM-PM-BNM-LINK

    grouping CFM-PM-BNM-LINK-BAG {
      description
        "BNM Enabled Link table entry";
      container bnm-enabled-link {
        description "BNM Enabled Link";
        uses CFM-PM-BNM-LINK;
      }  // container bnm-enabled-link

      leaf level {
        type Cfm-bag-md-level;
        description "Maintenance level";
      }

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

      leaf mep-direction-xr {
        type Cfm-bag-direction;
        description "MEP facing direction";
      }
    }  // grouping CFM-PM-BNM-LINK-BAG

    grouping CFM-PM-TIMESTAMP {
      description "Timestamp";
      leaf seconds {
        type uint32;
        units "second";
        description "Seconds";
      }

      leaf nanoseconds {
        type uint32;
        units "nanosecond";
        description "Nanoseconds";
      }
    }  // grouping CFM-PM-TIMESTAMP

    grouping CFM-PM-RMEP-ERR-STATE {
      description
        "Error state of a Peer MEP";
      leaf loss-threshold-exceeded {
        type boolean;
        description
          "Timed out (loss threshold exceeded)";
      }

      leaf invalid-level {
        type boolean;
        description "Invalid level";
      }

      leaf invalid-maid {
        type boolean;
        description "Invalid MAID";
      }

      leaf invalid-ccm-interval {
        type boolean;
        description "Invalid CCM interval";
      }

      leaf received-our-mac {
        type boolean;
        description
          "Loop detected (our MAC address received)";
      }

      leaf received-our-mep-id {
        type boolean;
        description
          "Configuration Error (our MEP ID received)";
      }

      leaf received-rdi {
        type boolean;
        description
          "Remote defection indication received";
      }
    }  // grouping CFM-PM-RMEP-ERR-STATE

    grouping CFM-PM-DEFECTS {
      description
        "Defects detected from peer MEPs";
      container remote-meps-defects {
        description
          "Defects detected from remote MEPs";
        uses CFM-PM-RMEP-ERR-STATE;
      }  // container remote-meps-defects

      leaf ais-received {
        type boolean;
        description "AIS or LCK received";
      }

      leaf peer-meps-that-timed-out {
        type uint32;
        description
          "Number of peer MEPs that have timed out";
      }

      leaf missing {
        type uint32;
        description
          "Number of missing peer MEPs";
      }

      leaf auto-missing {
        type uint32;
        description
          "Number of missing auto cross-check MEPs";
      }

      leaf unexpected {
        type uint32;
        description
          "Number of unexpected peer MEPs";
      }

      leaf local-port-status {
        type boolean;
        description
          "The local port or interface is down";
      }

      leaf peer-port-status {
        type boolean;
        description
          "A peer port or interface is down";
      }
    }  // grouping CFM-PM-DEFECTS

    grouping CFM-PM-AIS-STATS {
      description "AIS statistics";
      container defects {
        description "Defects detected";
        uses CFM-PM-DEFECTS;
      }  // container defects

      container last-started {
        description
          "Time elapsed since sending last started";
        uses CFM-PM-TIMESTAMP;
      }  // container last-started

      leaf direction {
        type Cfm-bag-direction;
        description
          "Direction of AIS packets";
      }

      leaf lowest-level {
        type Cfm-bag-md-level;
        description
          "Level of the lowest MEP transmitting AIS";
      }

      leaf transmission-level {
        type Cfm-bag-md-level;
        description
          "Level that AIS packets are transmitted on";
      }

      leaf transmission-interval {
        type Cfm-bag-ais-interval;
        description
          "Interval at which AIS packets are transmitted";
      }

      leaf sent-packets {
        type uint32;
        description
          "Total number of packets sent by the transmitting
         MEP";
      }

      leaf-list via-level {
        type Cfm-bag-md-level;
        description
          "Levels of other MEPs receiving AIS";
      }
    }  // grouping CFM-PM-AIS-STATS

    grouping CFM-PM-EFP-AIS-BAG {
      description
        "Local interface AIS table entry";
      container statistics {
        description "AIS statistics";
        uses CFM-PM-AIS-STATS;
      }  // container statistics

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

      leaf interface-state {
        type string;
        description "IM Interface state";
      }

      leaf interworking-state {
        type Cfm-bag-iw-state;
        description
          "Interface interworking state";
      }

      leaf stp-state {
        type Cfm-bag-stp-state;
        description "STP state";
      }
    }  // grouping CFM-PM-EFP-AIS-BAG
  }  // submodule Cisco-IOS-XR-ethernet-cfm-oper-sub2