submodule Cisco-IOS-XR-bundlemgr-oper-sub2 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-bundlemgr-oper {
        prefix Cisco-IOS-XR-bundlemgr-oper;
    }

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

    include Cisco-IOS-XR-bundlemgr-oper-sub1 {
      revision-date "2020-10-01";
    }

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

    revision "2020-10-01" {
      description
        "64 bit bandwidth support
       2020-09-03
         Removed event-telemetry annotation from leaf interface-name of grouping BM-MEMBER-DATA";
    }

    revision "2019-05-30" {
      description
        "64 bit bandwidth changes.";
    }

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

    revision "2018-08-18" {
      description "Added a new leaf";
    }

    revision "2018-07-25" {
      description "Added a new leaf";
    }

    revision "2018-04-30" {
      description "Description updated.";
    }

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

    revision "2016-02-22" {
      description "Description updated.";
    }

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

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

    typedef Bml-timestamp {
      type uint64;
      description "Bml timestamp";
    }

    typedef Bmd-mlacp-mbr-state-enum {
      type enumeration {
        enum "mbr-state-nak" {
          value 0;
          description "Member info NAK'd";
        }
        enum "mbr-state-unknown" {
          value 1;
          description
            "No member state TLV received";
        }
        enum "mbr-state-up" {
          value 2;
          description "Member is up";
        }
        enum "mbr-state-down" {
          value 3;
          description "Member is down";
        }
        enum "mbr-state-admin-down" {
          value 4;
          description "Member is admin down";
        }
        enum "mbr-state-test" {
          value 5;
          description
            "Member state TLV reported test";
        }
        enum "mbr-state-error" {
          value 6;
          description
            "Member state TLV reported error";
        }
      }
      description "State of an mLACP device";
    }

    typedef Bmd-mlacp-bdl-state-enum {
      type enumeration {
        enum "bdl-state-nak" {
          value 0;
          description "Bundle info NAK'd";
        }
        enum "bdl-state-unknown" {
          value 1;
          description
            "No bundle state TLV received";
        }
        enum "bdl-state-no-sync" {
          value 2;
          description
            "No bundle config TLV with sync bit set received";
        }
        enum "bdl-state-rec-delay" {
          value 3;
          description
            "Revertive delay timer running";
        }
        enum "bdl-state-up" {
          value 4;
          description "Bundle is up";
        }
        enum "bdl-state-down" {
          value 5;
          description "Bundle is down";
        }
        enum "bdl-state-admin-down" {
          value 6;
          description "Bundle is admin down";
        }
        enum "bdl-state-test" {
          value 7;
          description
            "Bundle state TLV reported test";
        }
        enum "bdl-state-error" {
          value 8;
          description
            "Bundle state TLV reported error";
        }
      }
      description "State of an mLACP device";
    }

    typedef Bmd-mlacp-node-sync-enum {
      type enumeration {
        enum "node-sync-req" {
          value 0;
          description
            "Sync requested of device";
        }
        enum "node-sync-done" {
          value 1;
          description
            "Sync performed by device";
        }
        enum "node-sync-start" {
          value 2;
          description
            "Sync in progress from device";
        }
        enum "node-sync-init" {
          value 3;
          description
            "Initial sync pending from device";
        }
        enum "node-sync-singleton" {
          value 4;
          description
            "Sync not required for singleton groups";
        }
      }
      description
        "Synchronization states of an mLACP device";
    }

    typedef Bmd-mlacp-node-state-enum {
      type enumeration {
        enum "node-state-incomplete" {
          value 0;
          description
            "Missing some mLACP IG config";
        }
        enum "node-state-conn-rejected" {
          value 1;
          description
            "Connection rejected by peer";
        }
        enum "node-state-connect-sent" {
          value 2;
          description
            "Connect timer running";
        }
        enum "node-state-unconfigured" {
          value 3;
          description
            "Missing some ICCP IG config";
        }
        enum "node-state-unreachable" {
          value 4;
          description
            "ICCP declared peer node unreachable";
        }
        enum "node-state-iccp-down" {
          value 5;
          description
            "ICCP declared peer node down";
        }
        enum "node-state-nak" {
          value 6;
          description "System info NAK'd";
        }
        enum "node-state-unknown" {
          value 7;
          description
            "No system state TLV received";
        }
        enum "node-state-mlacp-down" {
          value 8;
          description
            "System state TLV reported down";
        }
        enum "node-state-admin-down" {
          value 9;
          description
            "System state TLV reported admin down";
        }
        enum "node-state-pe-isolated" {
          value 10;
          description
            "System is isolated from core network";
        }
        enum "node-state-error" {
          value 11;
          description
            "System state TLV reported error";
        }
        enum "node-state-test" {
          value 12;
          description
            "System state TLV reported test";
        }
        enum "node-state-up" {
          value 13;
          description "System is up";
        }
      }
      description "State of an mLACP device";
    }

    typedef Bmd-node-ldp-id {
      type Bm-in4-addr;
      description "Bmd node ldp id";
    }

    typedef Lacp-churnstates {
      type enumeration {
        enum "no-churn" {
          value 1;
          description
            "The port is synchronized correctly";
        }
        enum "churn" {
          value 2;
          description
            "The port is OutOfSync and the churn timer has
           expired";
        }
        enum "churn-monitor" {
          value 3;
          description
            "The port is OutOfSync but the churn timer has
           not expired";
        }
      }
      description "Lacp churnstates";
    }

    typedef Rxstates {
      type enumeration {
        enum "current-rx" {
          value 1;
          description "current rx";
        }
        enum "expired" {
          value 2;
          description "expired";
        }
        enum "defaulted" {
          value 3;
          description "defaulted";
        }
        enum "initialize" {
          value 4;
          description "initialize";
        }
        enum "lacp-disabled" {
          value 5;
          description "lacp disabled";
        }
        enum "port-disabled" {
          value 6;
          description "port disabled";
        }
      }
      description "Rxstates";
    }

    typedef Lacp-period-state {
      type enumeration {
        enum "period-s-low" {
          value 0;
          description
            "Packets are being sent using a long period";
        }
        enum "period-fast" {
          value 1;
          description
            "Packets are being sent using a short period";
        }
        enum "period-none" {
          value 2;
          description
            "Packets are not being sent";
        }
      }
      description "Lacp period state";
    }

    typedef Lacp-sel-state {
      type enumeration {
        enum "unselected" {
          value 0;
          description
            "The link is Unselected";
        }
        enum "standby" {
          value 1;
          description "The link is Standby";
        }
        enum "selected" {
          value 2;
          description "The link is Selected";
        }
      }
      description "Lacp sel state";
    }

    typedef Bm-link-period-value {
      type uint32;
      description "Bm link period value";
    }

    typedef Bm-link-state-bits {
      type uint8;
      description "Bm link state bits";
    }

    typedef Bm-link-number {
      type uint16;
      description "Bm link number";
    }

    typedef Bm-bdl-id {
      type uint16;
      description "Bm bdl id";
    }

    typedef Bmd-bag-event-rg-item {
      type enumeration {
        enum "bmd-event-rg-idb-create" {
          value 0;
          description "RG structure created";
        }
        enum "bmd-event-rg-configured" {
          value 1;
          description
            "RG configured by user";
        }
        enum "bmd-event-rg-user-config" {
          value 2;
          description
            "User changed the configuration";
        }
        enum "bmd-event-rg-connect-ion" {
          value 3;
          description "Connection to peer";
        }
        enum "bmd-event-rg-data" {
          value 4;
          description "Data received";
        }
        enum "bmd-event-rg-sync" {
          value 5;
          description "Sync performed";
        }
        enum "bmd-event-rg-first-retry" {
          value 6;
          description "First retry";
        }
        enum "bmd-event-rg-error" {
          value 7;
          description "Last error";
        }
        enum "bmd-event-rg-mlacp-tlv" {
          value 8;
          description "mLACP TLV received";
        }
        enum "bmd-event-rg-iccp-event" {
          value 9;
          description "ICCP event received";
        }
        enum "bmd-event-rg-count" {
          value 10;
          description "Number of RG events";
        }
      }
      description
        "Description of an event for a RG";
    }

    typedef Bmd-bag-event-bdl-item {
      type enumeration {
        enum "bmd-event-bdl-idb-create" {
          value 0;
          description
            "Bundle structure created";
        }
        enum "bmd-event-bdl-configured" {
          value 1;
          description
            "Bundle configured by user";
        }
        enum "bmd-event-bdl-im-state" {
          value 2;
          description
            "Bundle's IM state changed";
        }
        enum "bmd-event-bdl-mbr-added" {
          value 3;
          description
            "Member added to the bundle";
        }
        enum "bmd-event-bdl-mbr-deleted" {
          value 4;
          description
            "Member removed from the bundle";
        }
        enum "bmd-event-bdl-mac-addr" {
          value 5;
          description
            "Bundle's MAC address changed";
        }
        enum "bmd-event-bdl-first-retry" {
          value 6;
          description "First retry";
        }
        enum "bmd-event-bdl-user-config" {
          value 7;
          description
            "User changed the configuration";
        }
        enum "bmd-event-bdl-error" {
          value 8;
          description "Last error";
        }
        enum "bmd-event-bdl-mlacp-tlv" {
          value 9;
          description "mLACP TLV received";
        }
        enum "bmd-event-bdl-redundancy-role" {
          value 10;
          description
            "redundancy role change";
        }
        enum "bdl-bfd-state-change" {
          value 11;
          description "BFD state change";
        }
        enum "bmd-event-bdl-icl" {
          value 12;
          description
            "Inter-chassis link mode changed";
        }
        enum "bmd-event-bdl-count" {
          value 13;
          description
            "Number of bundle events";
        }
      }
      description
        "Description of an event for a bundle";
    }

    typedef Bmd-bag-item-string {
      type string;
      description "Bmd bag item string";
    }

    typedef Bmd-bag-event-data {
      type enumeration {
        enum "bmd-bag-evt-data-none" {
          value 0;
          description "No additional data";
        }
        enum "bmd-bag-evt-data-error" {
          value 1;
          description
            "Additional data is an error code";
        }
        enum "bmd-bag-evt-data-string" {
          value 2;
          description
            "Additional data is a string";
        }
      }
      description
        "Type of additional info for an event";
    }

    typedef Bmd-bag-event-mbr-item {
      type enumeration {
        enum "bmd-event-mbr-idb-create" {
          value 0;
          description
            "Member structure created";
        }
        enum "bmd-event-mbr-bdl-add" {
          value 1;
          description "Added to bundle";
        }
        enum "bmd-event-mbr-im-state" {
          value 2;
          description
            "Member's IM state changed";
        }
        enum "bmd-event-mbr-sel-logic" {
          value 3;
          description
            "Sel logic state changed";
        }
        enum "bmd-event-mbr-mux" {
          value 4;
          description "Mux state changed";
        }
        enum "bmd-event-mbr-bfd" {
          value 5;
          description "BFD state changed";
        }
        enum "bmd-event-mbr-expired" {
          value 6;
          description "Expired";
        }
        enum "bmd-event-mbr-defaulted" {
          value 7;
          description "Defaulted";
        }
        enum "bmd-event-mbr-first-retry" {
          value 8;
          description "First retry";
        }
        enum "bmd-event-mbr-msg" {
          value 9;
          description "Message from BML";
        }
        enum "bmd-event-mbr-error" {
          value 10;
          description "Last error";
        }
        enum "bmd-event-mbr-mlacp-tlv" {
          value 11;
          description "mLACP TLV received";
        }
        enum "bmd-event-mbr-redundancy-role" {
          value 12;
          description
            "redundancy role change";
        }
        enum "bmd-event-mbr-count" {
          value 13;
          description
            "Number of member events";
        }
      }
      description
        "Description of an event for a member";
    }

    typedef Bmd-bag-target {
      type enumeration {
        enum "bm-bag-target-mbr" {
          value 0;
          description
            "Information for a member";
        }
        enum "bm-bag-target-bdl" {
          value 1;
          description
            "Information for a bundle";
        }
        enum "bm-bag-target-node" {
          value 2;
          description
            "Information for a node";
        }
        enum "bm-bag-target-rg" {
          value 3;
          description
            "Information for an RG";
        }
      }
      description "Scope of information";
    }

    typedef Bmd-switch-reason {
      type enumeration {
        enum "bm-switch-reason-none" {
          value 0;
          description "Switch is permitted";
        }
        enum "bm-switch-reason-noop" {
          value 1;
          description "Switch has no effect";
        }
        enum "bm-switch-reason-not-mlacp" {
          value 2;
          description "mLACP not configured";
        }
        enum "bm-switch-reason-revertive" {
          value 3;
          description
            "Brute-force or revertive switchover is in
           effect";
        }
        enum "bm-switch-reason-bdl-down" {
          value 4;
          description
            "Would-be active bundle is not ready";
        }
        enum "bm-switch-reason-recovery" {
          value 5;
          description
            "Recovery delay in effect, applications may not
           be fully synced";
        }
        enum
          "bm-switch-reason-preceding-error" {
          value 6;
          description
            "Preceding switch action not viable";
        }
        enum "bm-switch-reason-wrong-order" {
          value 7;
          description
            "Switch actions are scheduled incorrectly";
        }
        enum "bm-switch-reason-singleton" {
          value 8;
          description
            "The ICCP group is operating in singleton mode";
        }
      }
      description "Bmd switch reason";
    }

    typedef Bmd-bag-mlacp-sch-action-item {
      type enumeration {
        enum "switchover" {
          value 0;
          description
            "mLACP Switchover scheduled";
        }
        enum "switchback" {
          value 1;
          description
            "mLACP Switchback scheduled";
        }
      }
      description
        "Description of scheduled actions for a bundle";
    }

    typedef Bmd-member-type-enum {
      type enumeration {
        enum "bmd-mbr-local" {
          value 0;
          description
            "Member has been configured on the local device";
        }
        enum "bmd-mbr-foreign" {
          value 1;
          description
            "Member has been configured on an mLACP peer
           device";
        }
        enum "bmd-mbr-unknown" {
          value 2;
          description
            "Member's type is unknown";
        }
      }
      description "Bmd member type enum";
    }

    typedef Bm-muxreason {
      type enumeration {
        enum "bm-mux-reason-no-reason" {
          value 0;
          description
            "Selection logic has not yet been run for the
           bundle this link is a member of";
        }
        enum "bm-mux-reason-link-down" {
          value 1;
          description "Link is down";
        }
        enum "bm-mux-reason-link-deleted" {
          value 2;
          description
            "Link is being removed from the bundle";
        }
        enum "bm-mux-reason-duplex" {
          value 3;
          description
            "Link has wrong duplexity";
        }
        enum "bm-mux-reason-bandwidth" {
          value 4;
          description
            "Link has wrong bandwidth";
        }
        enum "bm-mux-reason-loop-back" {
          value 5;
          description
            "Link is a loopback interface";
        }
        enum "bm-mux-reason-activity-type" {
          value 6;
          description
            "Link has wrong activity type";
        }
        enum "bm-mux-reason-link-limit" {
          value 7;
          description
            "Link's bundle already has maximum number of
           members allowed";
        }
        enum "bm-mux-reason-shared" {
          value 8;
          description
            "Link is attached to a shared medium";
        }
        enum "bm-mux-reason-lagid" {
          value 9;
          description
            "Link has wrong LAG ID";
        }
        enum "bm-mux-reason-no-bundle" {
          value 10;
          description
            "Link's bundle does not exist";
        }
        enum "bm-mux-reason-no-primary" {
          value 11;
          description
            "Link's bundle has no primary link";
        }
        enum "bm-mux-reason-bundle-down" {
          value 12;
          description
            "Link's bundle is shut down";
        }
        enum "bm-mux-reason-individual" {
          value 13;
          description
            "Link is marked individual by partner";
        }
        enum "bm-mux-reason-defaulted" {
          value 14;
          description
            "Link is Defaulted, suggesting it is not
           receiving LACPDUs from the peer";
        }
        enum "bm-mux-reason-in-sync" {
          value 15;
          description
            "Link is in InSync state";
        }
        enum "bm-mux-reason-collecting" {
          value 16;
          description
            "Link is in Collecting state";
        }
        enum
          "bm-mux-reason-active-link-limit" {
          value 17;
          description
            "Link exceeds maximum active limit";
        }
        enum "bm-mux-reason-distributing" {
          value 18;
          description
            "Link is in Distributing state";
        }
        enum "bm-mux-reason-plat-data" {
          value 19;
          description
            "Link platform data is incompatible with
           selected members";
        }
        enum "bm-mux-reason-count" {
          value 20;
          description
            "Enumeration maximum value";
        }
      }
      description "Bm muxreason";
    }

    typedef Bmd-member-state {
      type enumeration {
        enum "bmd-mbr-state-configured" {
          value 1;
          description "Member is configured";
        }
        enum "bmd-mbr-state-standby" {
          value 2;
          description "Member is standby";
        }
        enum "bmd-mbr-state-hot-standby" {
          value 3;
          description
            "Member is hot standby";
        }
        enum "bmd-mbr-state-negotiating" {
          value 4;
          description
            "Member is negotiating";
        }
        enum "bmd-mbr-state-bfd-running" {
          value 5;
          description
            "Member has a BFD session running";
        }
        enum "bmd-mbr-state-active" {
          value 6;
          description "Member is active";
        }
      }
      description "Bmd member state";
    }

    typedef Bm-severity {
      type enumeration {
        enum "ok" {
          value 0;
          description "OK";
        }
        enum "information" {
          value 1;
          description "Information";
        }
        enum "misconfiguration" {
          value 2;
          description "Misconfiguration";
        }
        enum "warning" {
          value 3;
          description "Warning";
        }
        enum "error" {
          value 5;
          description "Error";
        }
      }
      description
        "Severity of the member state reason";
    }

    typedef Bm-state-reason-target {
      type enumeration {
        enum "member-reason" {
          value 0;
          description
            "Member applicable reason";
        }
        enum "bundle-reason" {
          value 1;
          description
            "Bundle applicable reason";
        }
      }
      description
        "Scope of the state reason";
    }

    typedef Bm-mbr-state-reason {
      type enumeration {
        enum "bm-mbr-state-reason-unknown" {
          value 0;
          description
            "Reason unavailable (diagnostics error)";
        }
        enum
          "bm-mbr-state-reason-unselectable-unknown" {
          value 1;
          description
            "Link cannot be used (unknown reason)";
        }
        enum "bm-mbr-state-reason-link-down" {
          value 2;
          description "Link is down";
        }
        enum
          "bm-mbr-state-reason-link-deleting" {
          value 3;
          description
            "Link is being removed from the bundle";
        }
        enum "bm-mbr-state-reason-creating" {
          value 4;
          description
            "Link is in the process of being created";
        }
        enum
          "bm-mbr-state-reason-bundle-creating" {
          value 5;
          description
            "Bundle is in the process of being created";
        }
        enum
          "bm-mbr-state-reason-bundle-deleting" {
          value 6;
          description
            "Bundle is in the process of being deleted";
        }
        enum
          "bm-mbr-state-reason-bundle-admin-down" {
          value 7;
          description
            "Bundle has been shut down";
        }
        enum
          "bm-mbr-state-reason-replicating" {
          value 8;
          description
            "Bundle is in the process of being replicated to
           this location";
        }
        enum "bm-mbr-state-reason-bandwidth" {
          value 9;
          description
            "Incompatible with other links in the bundle
           (bandwidth out of range)";
        }
        enum "bm-mbr-state-reason-loop-back" {
          value 10;
          description
            "Loopback: Actor and Partner have the same
           System ID and Key";
        }
        enum
          "bm-mbr-state-reason-activity-type" {
          value 11;
          description
            "Incompatible with other links in the bundle
           (LACP vs non-LACP)";
        }
        enum
          "bm-mbr-state-reason-bundle-shutdown" {
          value 12;
          description
            "Bundle shutdown is configured for the bundle";
        }
        enum
          "bm-mbr-state-reason-min-selected" {
          value 13;
          description
            "Not enough links available to meet
           minimum-active threshold";
        }
        enum
          "bm-mbr-state-reason-max-selected" {
          value 14;
          description
            "Link is Standby due to maximum-active links
           configuration";
        }
        enum
          "bm-mbr-state-reason-link-limit" {
          value 15;
          description
            "Bundle has too many member links configured";
        }
        enum
          "bm-mbr-state-reason-active-limit" {
          value 16;
          description
            "Bundle has reached maximum supported number of
           active links";
        }
        enum
          "bm-mbr-state-reason-standby-unknown" {
          value 17;
          description
            "Link is Standby (unknown reason)";
        }
        enum "bm-mbr-state-reason-expired" {
          value 18;
          description
            "Link is Expired; LACPDUs are not being received
           from the partner";
        }
        enum "bm-mbr-state-reason-defaulted" {
          value 19;
          description
            "Link is Defaulted; LACPDUs are not being
           received from the partner";
        }
        enum
          "bm-mbr-state-reason-act-or-not-agg" {
          value 20;
          description
            "Link is Not Aggregatable (unknown reason)";
        }
        enum
          "bm-mbr-state-reason-partner-not-agg" {
          value 21;
          description
            "Partner has marked the link as Not Aggregatable";
        }
        enum "bm-mbr-state-reason-lagid" {
          value 22;
          description
            "Partner System ID/Key do not match that of the
           Selected links";
        }
        enum
          "bm-mbr-state-reason-bundle-not-cfgd" {
          value 23;
          description
            "Bundle interface is not present in
           configuration";
        }
        enum
          "bm-mbr-state-reason-bundle-not-ready" {
          value 24;
          description
            "Wait-while timer is running";
        }
        enum
          "bm-mbr-state-reason-partner-ood" {
          value 25;
          description
            "Partner has not echoed the correct parameters
           for this link";
        }
        enum
          "bm-mbr-state-reason-partner-not-in-sync" {
          value 26;
          description
            "Partner is not Synchronized (Waiting, Standby,
           or LAG ID mismatch)";
        }
        enum
          "bm-mbr-state-reason-foreign-partner-oos" {
          value 27;
          description
            "Partner is not Synchronized (Waiting, not
           Selected, or out-of-date)";
        }
        enum
          "bm-mbr-state-reason-attach-unknown" {
          value 28;
          description
            "Link is Attached and has not gone Collecting
           (unknown reason)";
        }
        enum
          "bm-mbr-state-reason-partner-not-collecting" {
          value 29;
          description
            "Partner has not advertized that it is
           Collecting";
        }
        enum
          "bm-mbr-state-reason-collect-unknown" {
          value 30;
          description
            "Link is Collecting and has not gone
           Distributing (unknown reason)";
        }
        enum
          "bm-mbr-state-reason-standby-foreign" {
          value 31;
          description
            "Link is marked as Standby by mLACP peer";
        }
        enum
          "bm-mbr-state-reason-bfd-starting" {
          value 32;
          description
            "Link is waiting for BFD session to start";
        }
        enum "bm-mbr-state-reason-bfd-down" {
          value 33;
          description
            "BFD state of this link is Down";
        }
        enum
          "bm-mbr-state-reason-bfd-nbr-unconfig" {
          value 34;
          description
            "BFD session is unconfigured on the remote end";
        }
        enum "bm-mbr-state-reason-mlacp" {
          value 35;
          description
            "Link is not operational as a result of mLACP
           negotiations";
        }
        enum
          "bm-mbr-state-reason-pe-isolated" {
          value 36;
          description
            "ICCP group is isolated from the core network";
        }
        enum
          "bm-mbr-state-reason-forced-switchover" {
          value 37;
          description
            "Forced switchover to the mLACP peer";
        }
        enum
          "bm-mbr-state-reason-errdis-unknown" {
          value 38;
          description
            "Link is error disabled (unknown reason)";
        }
        enum
          "bm-mbr-state-reason-mlacp-no-mbr-state-info" {
          value 39;
          description
            "Waiting for member state information from mLACP
           peer";
        }
        enum "bm-mbr-state-reason-active" {
          value 40;
          description "Link is Active";
        }
        enum
          "bm-mbr-state-reason-mlacp-no-bdl-state-info" {
          value 41;
          description
            "Waiting for bundle state information from mLACP
           peer";
        }
        enum
          "bm-mbr-state-reason-mlacp-no-bdl-config-info" {
          value 42;
          description
            "Waiting for bundle configuration information
           from mLACP peer";
        }
        enum
          "bm-mbr-state-reason-mlacp-no-bdl-sync" {
          value 43;
          description
            "Waiting for bundle to complete initial
           synchronization with mLACP peer";
        }
        enum
          "bm-mbr-state-reason-mlacp-bdl-has-no-peer" {
          value 44;
          description
            "mLACP bundle does not have a peer device";
        }
        enum "bm-mbr-state-reason-mlacp-nak" {
          value 45;
          description
            "Link is being ignored due to an inconsistency
           with mLACP peer";
        }
        enum
          "bm-mbr-state-reason-mlacp-transport-unavailable" {
          value 46;
          description
            "ICCP transport is unavailable";
        }
        enum
          "bm-mbr-state-reason-mlacp-not-configured" {
          value 47;
          description
            "ICCP Group is not fully configured";
        }
        enum
          "bm-mbr-state-reason-recovery-timer" {
          value 48;
          description
            "mLACP recovery delay timer is running";
        }
        enum
          "bm-mbr-state-reason-mlacp-standby" {
          value 49;
          description "mLACP peer is active";
        }
        enum
          "bm-mbr-state-reason-maximized-out" {
          value 50;
          description
            "mLACP peer has more links/bandwidth available";
        }
        enum
          "bm-mbr-state-reason-mlacp-peer-selected" {
          value 51;
          description
            "mLACP peer has one or more links Selected";
        }
        enum
          "bm-mbr-state-reason-mlacp-connect-timer-running" {
          value 52;
          description
            "mLACP bundle does not have a peer device
           (connect timer running)";
        }
        enum
          "bm-mbr-state-reason-bundle-not-mlacp" {
          value 53;
          description
            "Bundle is not configured to run mLACP";
        }
        enum "bm-mbr-state-reason-no-lon" {
          value 54;
          description
            "Bundle has too many working links configured
           (more than the maximum-active limit)";
        }
        enum
          "bm-mbr-state-reason-cumul-rel-bw-limit" {
          value 55;
          description
            "Additional bandwidth from link would exceed
           load balancing capabilities";
        }
        enum "bm-mbr-state-reason-no-mac" {
          value 56;
          description
            "No MAC address available for the bundle";
        }
        enum
          "bm-mbr-state-reason-no-system-id" {
          value 57;
          description
            "No system ID available for use by this bundle";
        }
        enum
          "bm-mbr-state-reason-link-shutdown" {
          value 58;
          description "Link is shutdown";
        }
        enum
          "bm-mbr-state-reason-activity-mlacp" {
          value 59;
          description
            "Non-LACP link in mLACP bundle";
        }
        enum
          "bm-mbr-state-reason-activity-iccp" {
          value 60;
          description
            "LACP link in inter-chassis bundle";
        }
        enum
          "bm-mbr-state-reason-bundle-icpe-mlacp" {
          value 61;
          description
            "Parent bundle is both inter-chassis and
           configured for mLACP";
        }
        enum
          "bm-mbr-state-reason-no-link-num" {
          value 62;
          description
            "Too many bundle members in system; no link
           number available";
        }
        enum
          "bm-mbr-state-reason-standby-peer-higher-prio" {
          value 63;
          description
            "mLACP peer has a higher priority link";
        }
        enum
          "bm-mbr-state-reason-red-state-standby" {
          value 64;
          description
            "Link is in standby redundancy state";
        }
        enum
          "bm-mbr-state-reason-other-red-state-standby" {
          value 65;
          description
            "One or more links in the bundle are in standby
           redundancy state";
        }
        enum "bm-mbr-state-reason-hold-ing" {
          value 66;
          description
            "Holding down temporary to avoid churn after
           restart";
        }
        enum
          "bm-mbr-state-reason-bundle-error-disabled" {
          value 67;
          description
            "Bundle has been error-disabled";
        }
        enum
          "bm-mbr-state-reason-bundle-efd-disabled" {
          value 68;
          description
            "Bundle has been disabled by EFD";
        }
        enum
          "bm-mbr-state-reason-singleton-pe-isolated" {
          value 69;
          description
            "Singleton ICCP group is isolated from the core
           network";
        }
        enum
          "bm-mbr-state-reason-bfd-ipv6-starting" {
          value 70;
          description
            "Link is waiting for BFDv6 session to start";
        }
        enum
          "bm-mbr-state-reason-bfd-ipv6-down" {
          value 71;
          description
            "BFDv6 state of this link is Down";
        }
        enum
          "bm-mbr-state-reason-bfd-ipv6-nbr-unconfig" {
          value 72;
          description
            "BFDv6 session is unconfigured on the remote end";
        }
        enum
          "bm-mbr-state-reason-timer-running" {
          value 73;
          description
            "LACP delay timer is running";
        }
        enum
          "bm-mbr-state-reason-client-bundle-ctrl" {
          value 74;
          description
            "Client has configured the bundle state Down";
        }
        enum "bm-mbr-state-reason-lacp-oos" {
          value 75;
          description
            "Link is in standby due to bundle out of service
           state";
        }
        enum
          "bm-mbr-state-reason-errdis-bundle-oos" {
          value 76;
          description
            "Link is error-disabled due to bundle out of
           service state";
        }
        enum "bm-mbr-state-reason-plat-data" {
          value 77;
          description
            "Incompatible with other links platform data in
           the bundle (Etm vs non ETM)";
        }
        enum "bm-mbr-state-reason-count" {
          value 78;
          description
            "Enumeration maximum value";
        }
      }
      description "Bm mbr state reason";
    }

    typedef Bm-muxstate {
      type enumeration {
        enum "detached" {
          value 1;
          description
            "Port is not attached to a bundle";
        }
        enum "waiting" {
          value 2;
          description
            "Port has chosen bundle and is waiting to join";
        }
        enum "attached" {
          value 3;
          description
            "Port is attached to the bundle but not active";
        }
        enum "collecting" {
          value 4;
          description
            "Port is ready to receive data";
        }
        enum "distributing" {
          value 5;
          description
            "Port is distributing data";
        }
        enum "collecting-distributing" {
          value 6;
          description
            "Port is active and can send and receive data";
        }
      }
      description "Bm muxstate";
    }

    typedef Bmd-lacp-mode {
      type enumeration {
        enum "bmd-mode-on" {
          value 0;
          description "bmd mode on";
        }
        enum "bmd-mode-active" {
          value 1;
          description "bmd mode active";
        }
        enum "bmd-mode-passive" {
          value 2;
          description "bmd mode passive";
        }
        enum "bmd-mode-count" {
          value 3;
          description "bmd mode count";
        }
      }
      description "Bmd lacp mode";
    }

    typedef Bmd-mlacp-switchover {
      type enumeration {
        enum
          "bmd-mlacp-switchover-nonrevertive" {
          value 0;
          description
            "Non-revertive switchover type";
        }
        enum
          "bmd-mlacp-switchover-brute-force" {
          value 1;
          description
            "Brute force switchover type";
        }
        enum
          "bmd-mlacp-switchover-revertive" {
          value 2;
          description
            "Revertive switchover type";
        }
        enum "bmd-mlacp-switchover-count" {
          value 3;
          description
            "Number of switchover types";
        }
      }
      description "Bmd mlacp switchover";
    }

    typedef Bm-feature-status {
      type enumeration {
        enum "bm-feature-not-configured" {
          value 0;
          description
            "No configuration is applied for a feature";
        }
        enum "bm-feature-not-operational" {
          value 1;
          description
            "The feature is currently not operational";
        }
        enum "bm-feature-operational" {
          value 2;
          description
            "The feature is currently operational";
        }
      }
      description "Bm feature status";
    }

    typedef Bm-bdl-mac-source {
      type enumeration {
        enum "bm-bdl-mac-source-unknown" {
          value 0;
          description
            "The MAC is currently unknown";
        }
        enum "bm-bdl-mac-source-chassis" {
          value 1;
          description
            "The MAC was allocated from the chassis pool";
        }
        enum "bm-bdl-mac-source-configured" {
          value 2;
          description
            "The MAC was configured by the user";
        }
        enum "bm-bdl-mac-source-member" {
          value 3;
          description
            "The MAC belongs to a member";
        }
        enum "bm-bdl-mac-source-peer" {
          value 4;
          description
            "The MAC has come from the peer device";
        }
      }
      description "Bm bdl mac source";
    }

    typedef Bm-bdl-state {
      type enumeration {
        enum "bm-bdl-state-admin-down" {
          value 0;
          description
            "The bundle has been configured Down";
        }
        enum "bm-bdl-state-down" {
          value 1;
          description "The bundle is Down";
        }
        enum "bm-bdl-state-client-down" {
          value 2;
          description
            "The bundle is controlled by CLIENT Down";
        }
        enum "bm-bdl-state-ptnr-down" {
          value 3;
          description
            "The bundle is Down on the partner device";
        }
        enum "bm-bdl-state-bundle-shutdown" {
          value 4;
          description
            "Bundle shutdown has been configured";
        }
        enum "bm-bdl-state-pe-isolated" {
          value 5;
          description
            "The bundle cannot contact the core";
        }
        enum "bm-bdl-state-nak" {
          value 6;
          description
            "The state is disputed by a peer device";
        }
        enum "bm-bdl-state-up-active" {
          value 7;
          description "The bundle is Up";
        }
        enum
          "bm-bdl-state-mlacp-hot-standby" {
          value 8;
          description
            "The bundle is Up, but is mLACP standby";
        }
        enum
          "bm-bdl-state-mlacp-cold-standby" {
          value 9;
          description
            "The bundle is mLACP standby, but will not
           eliminate traffic loss";
        }
        enum "bm-bdl-state-unknown" {
          value 10;
          description
            "The bundle state has not been determined";
        }
        enum "bm-bdl-state-cold-standby" {
          value 11;
          description
            "The bundle is standby, but will not eliminate
           traffic loss";
        }
        enum "bm-bdl-state-error-disabled" {
          value 12;
          description
            "The bundle has been error-disabled";
        }
        enum "bm-bdl-state-efd-disabled" {
          value 13;
          description
            "The bundle has been disabled by EFD";
        }
        enum "bm-bdl-state-lacp-oos" {
          value 14;
          description
            "The bundle has been OOS (Out of Service)";
        }
      }
      description "Bm bdl state";
    }

    typedef Bm-in6-addr {
      type inet:ipv6-address;
      description "Bm in6 addr";
    }

    typedef Bm-in4-addr {
      type inet:ipv4-address;
      description "Bm in4 addr";
    }

    typedef Bm-af-id {
      type enumeration {
        enum "bm-af-id-ipv4" {
          value 1136568623;
          description "IPv4 AFI";
        }
        enum "bm-af-id-ipv6" {
          value 1136568624;
          description "IPv6 AFI";
        }
      }
      description "Bm af id";
    }

    typedef Bmd-bfd-bdl-state {
      type enumeration {
        enum "bmd-bfd-bdl-down" {
          value 0;
          description
            "BFD is down on the bundle";
        }
        enum "bmd-bfd-bdl-unknown" {
          value 1;
          description
            "BFD has just started on a bundle, and the state
           has not been determined";
        }
        enum "bmd-bfd-bdl-up" {
          value 2;
          description
            "BFD is up on the bundle";
        }
        enum "bmd-bfd-bdl-count" {
          value 3;
          description
            "Number of BFD states on a bundle";
        }
      }
      description "Bmd bfd bdl state";
    }

    typedef Bm-which-system {
      type enumeration {
        enum "bm-which-system-actr" {
          value 0;
          description "Actor";
        }
        enum "bm-which-system-ptnr" {
          value 1;
          description "Partner";
        }
      }
      description "Bm which system";
    }

    grouping LACP-COUNTERS {
      description
        "Statistics for a port using using LACP";
      leaf lacpd-us-received {
        type uint32;
        description "LACPDUs received";
      }

      leaf lacpd-us-transmitted {
        type uint32;
        description "LACPDUs transmitted";
      }

      leaf marker-packets-received {
        type uint32;
        description
          "LACP Marker packets received";
      }

      leaf marker-responses-transmitted {
        type uint32;
        description
          "LACP Marker response packets transmitted";
      }

      leaf illegal-packets-received {
        type uint32;
        description
          "Illegal and unknown packets received";
      }

      leaf excess-lacpd-us-received {
        type uint32;
        description
          "LACPDUs received that exceed the rate limit";
      }

      leaf excess-marker-packets-received {
        type uint32;
        description
          "Marker packets received that exceed the rate
         limit";
      }

      leaf defaulted {
        type uint32;
        description
          "State flag set to Defaulted";
      }

      leaf expired {
        type uint32;
        description
          "State flag set to Expired";
      }

      leaf time-since-last-lacpdu-received {
        type Bml-timestamp;
        description
          "Time elapsed since last LACPDU received (nsec)";
      }

      leaf time-since-cleared {
        type Bml-timestamp;
        description
          "Time elapsed since counters last cleared (nsec)";
      }

      leaf time-since-unexpected-event {
        type Bml-timestamp;
        description
          "Time elapsed since last unexpected event (nsec)";
      }

      leaf last-cleared-sec {
        type uint32;
        description
          "Last time counters cleared (s) (deprecated)";
      }

      leaf last-cleared-nsec {
        type uint32;
        description
          "Last time counters cleared (nsec) (deprecated)";
      }
    }  // grouping LACP-COUNTERS

    grouping LACP-LINK-DATA {
      description
        "Link properties for a port using LACP
       (Deprecated)";
      leaf interface-handle {
        type xr:Interface-name;
        description
          "Member's interface handle";
      }

      leaf actor-system-priority {
        type uint16;
        description
          "System priority of the actor system";
      }

      leaf actor-system-mac-address {
        type yang:mac-address;
        description
          "MAC Address of the actor system";
      }

      leaf actor-operational-key {
        type uint16;
        description
          "Operational key for this port";
      }

      leaf partner-system-priority {
        type uint16;
        description
          "System priority of partner system";
      }

      leaf partner-system-mac-address {
        type yang:mac-address;
        description
          "MAC Address used to identify the partner system";
      }

      leaf partner-operational-key {
        type uint16;
        description
          "Operational key for partner port";
      }

      leaf selected-aggregator-id {
        type uint32;
        description
          "MIB ifindex of selected bundle";
      }

      leaf attached-aggregator-id {
        type uint32;
        description
          "MIB ifindex of attached bundle";
      }

      leaf actor-port-id {
        type uint16;
        description
          "Port number of this port";
      }

      leaf actor-port-priority {
        type uint16;
        description "Priority of this port";
      }

      leaf partner-port-id {
        type uint16;
        description
          "Port number of the partner's port";
      }

      leaf partner-port-priority {
        type uint16;
        description
          "Priority of the partner's port";
      }

      leaf actor-port-state {
        type uint8;
        description
          "LACP state of this port";
      }

      leaf partner-port-state {
        type uint8;
        description
          "LACP state of the partner's port";
      }
    }  // grouping LACP-LINK-DATA

    grouping LACP-DROPS {
      description
        "Otherwise unaccounted LACP drops for a node";
      leaf wrong-port-count {
        type uint32;
        description
          "LACP protocol packets received on ports with
         LACP inactive/off";
      }

      leaf last-wrong-port {
        type uint32;
        description
          "Last unrecognized port on which a packet was
         received";
      }

      leaf unknown-port-count {
        type uint32;
        description
          "Packets received for which rx port could not be
         determined";
      }

      leaf undecodable-packets {
        type uint32;
        description
          "Packets received which could not be decoded";
      }

      leaf time-since-cleared {
        type Bml-timestamp;
        units "nanosecond";
        description
          "Time elapsed since counters were last cleared
         (in nanoseconds)";
      }

      leaf time-since-unexpected-event {
        type Bml-timestamp;
        units "nanosecond";
        description
          "Time elapsed since last unexpected event (in
         nanoseconds)";
      }

      leaf time-since-last-updated {
        type Bml-timestamp;
        units "nanosecond";
        description
          "Time elapsed since statistics were last updated
         (in nanoseconds)";
      }
    }  // grouping LACP-DROPS

    grouping BM-BUNDLE-APPLIED-LACP-MODE {
      description
        "Applied LACP Mode for bundle interface";
      leaf applied-lacp-mode {
        type Bmd-lacp-mode;
        description "Applied LACP Mode";
      }
    }  // grouping BM-BUNDLE-APPLIED-LACP-MODE

    grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-MBR {
      description
        "Per member mLACP TLV counter information";
      container mlacp-tlv-counters {
        description
          "Counts of mLACP TLVs sent and received";
        uses BMD-BAG-MLACP-TLV-COUNTERS;
      }  // container mlacp-tlv-counters

      leaf port-name {
        type string;
        description "Port name of member";
      }
    }  // grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-MBR

    grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-NODE-DATA {
      description
        "Peer device specific mLACP TLV counter
       information";
      leaf node-id {
        type uint32;
        description "Device ID";
      }

      leaf iccp-group-id {
        type uint32;
        description "ICCP Group ID";
      }
    }  // grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-NODE-DATA

    grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-NODE {
      description
        "Per peer device mLACP TLV counter information";
      container node-data {
        description
          "Peer device mLACP TLV counter information";
        uses BMD-BAG-MBR-INFO-MLACP-COUNTERS-NODE-DATA;
      }  // container node-data

      container mlacp-sync-requests-on-all-foreign-ports {
        description
          "Counts of mLACP sync request TLVs on all ports";
        uses OPTIONAL-SYNC-REQUEST-COUNTERS;
      }  // container mlacp-sync-requests-on-all-foreign-ports

      list member-data {
        description
          "Member mLACP TLV counter information";
        uses BMD-BAG-MBR-INFO-MLACP-COUNTERS-MBR;
      }  // list member-data
    }  // grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-NODE

    grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-BDL-DATA {
      description
        "Bundle specific mLACP TLV counter information";
      container mlacp-sync-requests-on-all-local-ports {
        description
          "Counts of mLACP sync request TLVs on all ports";
        uses OPTIONAL-SYNC-REQUEST-COUNTERS;
      }  // container mlacp-sync-requests-on-all-local-ports

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

      leaf iccp-group-id {
        type uint32;
        description "ICCP Group ID";
      }
    }  // grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-BDL-DATA

    grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-BDL {
      description
        "Per bundle mLACP TLV counter information";
      container bundle-data {
        description
          "Bundle mLACP TLV counter information";
        uses BMD-BAG-MBR-INFO-MLACP-COUNTERS-BDL-DATA;
      }  // container bundle-data

      list node-data {
        description
          "Peer device mLACP TLV counter information";
        uses BMD-BAG-MBR-INFO-MLACP-COUNTERS-NODE;
      }  // list node-data

      list member-data {
        description
          "Local member mLACP TLV counter information";
        uses BMD-BAG-MBR-INFO-MLACP-COUNTERS-MBR;
      }  // list member-data
    }  // grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-BDL

    grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-RG {
      description
        "mLACP counter information for multiple items";
      list items {
        description
          "mLACP counter information items";
        uses BMD-BAG-MBR-INFO-MLACP-COUNTERS-BDL;
      }  // list items
    }  // grouping BMD-BAG-MBR-INFO-MLACP-COUNTERS-RG

    grouping LACP-SYSTEM-ID {
      description
        "LACP System identification information";
      container system-id {
        description "System ID";
        uses BM-SYSTEM-ID-TYPE;
      }  // container system-id

      leaf iccp-group-id {
        type uint32;
        description
          "ICCP Group that the system ID is for";
      }

      leaf system-priority {
        type uint16;
        description
          "Priority of the system (deprecated)";
      }

      leaf system-mac-address {
        type yang:mac-address;
        description
          "MAC Address used to identify the system
         (deprecated)";
      }
    }  // grouping LACP-SYSTEM-ID

    grouping BMD-BAG-MLACP-ICCP-EVENT-COUNTERS {
      description "Counts of ICCP events";
      leaf transport-up {
        type uint32;
        description
          "Number of transport up events";
      }

      leaf transport-down {
        type uint32;
        description
          "Number of transport down events";
      }

      leaf transport-unavailable {
        type uint32;
        description
          "Number of transport unavailable events";
      }

      leaf configured-set {
        type uint32;
        description
          "Number of configure events";
      }

      leaf configured-clear {
        type uint32;
        description
          "Number of unconfigure events";
      }

      leaf reachability-set {
        type uint32;
        description
          "Number of reachability events";
      }

      leaf reachability-cleared {
        type uint32;
        description
          "Number of reachability cleared events";
      }

      leaf member-status-up {
        type uint32;
        description
          "Number of member status up events";
      }

      leaf member-status-down {
        type uint32;
        description
          "Number of member status down events";
      }

      leaf pe-isolated {
        type uint32;
        description
          "Number of PE isolation events";
      }

      leaf pe-isolated-clear {
        type uint32;
        description
          "Number of PE isolation cleared events";
      }
    }  // grouping BMD-BAG-MLACP-ICCP-EVENT-COUNTERS

    grouping BMD-BAG-MLACP-ICCP-MSG-COUNTERS {
      description "Counts of ICCP messages";
      leaf sent-messages {
        type uint32;
        description
          "Number of messages sent";
      }

      leaf sent-buffer-messages {
        type uint32;
        description
          "Number of buffers sent (may be multiple per
         message)";
      }

      leaf received-messages {
        type uint32;
        description
          "Number of messages received";
      }

      leaf transmission-errors {
        type uint32;
        description
          "Number of transmission errors";
      }
    }  // grouping BMD-BAG-MLACP-ICCP-MSG-COUNTERS

    grouping BMD-BAG-MLACP-INVALID-TLV-COUNTERS {
      description
        "Counts of invalid TLVs received";
      leaf incorrect-length {
        type uint32;
        description
          "Number of messages received of an incorrect
         length";
      }

      leaf invalid-type {
        type uint32;
        description
          "Number of messages received with an invalid
         mLACP TLV type";
      }

      leaf invalid-data {
        type uint32;
        description
          "Number of messages received containing invalid
         data";
      }

      leaf unknown-bundle {
        type uint32;
        description
          "Number of messages received for an unknown
         bundle";
      }

      leaf unknown-port {
        type uint32;
        description
          "Number of messages received for an unknown port";
      }
    }  // grouping BMD-BAG-MLACP-INVALID-TLV-COUNTERS

    grouping BMD-BAG-MLACP-RG-TLV-COUNTERS {
      description
        "Counts of ICCP level TLVs";
      leaf sent-config {
        type uint32;
        description
          "Number of config TLVs sent";
      }

      leaf received-config {
        type uint32;
        description
          "Number of config TLVs received";
      }

      leaf sent-state {
        type uint32;
        description
          "Number of state TLVs sent";
      }

      leaf received-state {
        type uint32;
        description
          "Number of state TLVs received";
      }

      leaf sent-na-ks {
        type uint32;
        description
          "Number of NAK TLVs sent";
      }

      leaf received-na-ks {
        type uint32;
        description
          "Number of NAK TLVs received";
      }

      leaf sent-sync-requests {
        type uint32;
        description
          "Number of sync request TLVs sent";
      }

      leaf received-sync-requests {
        type uint32;
        description
          "Number of sync request TLVs received";
      }

      leaf sent-state-sync-requests {
        type uint32;
        description
          "Number of state sync request TLVs sent";
      }

      leaf received-state-sync-requests {
        type uint32;
        description
          "Number of state sync request TLVs received";
      }

      leaf sent-config-sync-requests {
        type uint32;
        description
          "Number of config sync request TLVs sent";
      }

      leaf received-config-sync-requests {
        type uint32;
        description
          "Number of state config request TLVs received";
      }

      leaf sent-solicited-sync-data {
        type uint32;
        description
          "Number of solicited sync data TLVs sent";
      }

      leaf received-solicited-sync-data {
        type uint32;
        description
          "Number of solicited sync data TLVs received";
      }

      leaf sent-unsolicited-sync-data {
        type uint32;
        description
          "Number of unsolicited sync data TLVs sent";
      }

      leaf received-unsolicited-sync-data {
        type uint32;
        description
          "Number of unsolicited sync data TLVs received";
      }
    }  // grouping BMD-BAG-MLACP-RG-TLV-COUNTERS

    grouping BMD-BAG-MLACP-CONNECTION-COUNTERS {
      description
        "Counts of connection events";
      leaf sent-connects {
        type uint32;
        description
          "Number of connect TLVs sent";
      }

      leaf received-connects {
        type uint32;
        description
          "Number of connect TLVs received";
      }

      leaf iccp-invalid-connects {
        type uint32;
        description
          "Number of invalid ICCP connects";
      }

      leaf iccp-config-connect-errors {
        type uint32;
        description
          "Number of ICCP connection errors due to config";
      }

      leaf iccp-count-connect-errors {
        type uint32;
        description
          "Number of ICCP connection errors due to max ICCP
         group count";
      }

      leaf sent-wrong-versions {
        type uint32;
        description
          "Number of wrong version TLVs sent";
      }

      leaf received-wrong-versions {
        type uint32;
        description
          "Number of wrong version TLVs received";
      }

      leaf sent-disconnects {
        type uint32;
        description
          "Number of disconnect TLVs sent";
      }

      leaf received-disconnects {
        type uint32;
        description
          "Number of disconnect TLVs received";
      }

      leaf iccp-invalid-disconnects {
        type uint32;
        description
          "Number of invalid ICCP disconnects";
      }
    }  // grouping BMD-BAG-MLACP-CONNECTION-COUNTERS

    grouping BMD-BAG-RG-INFO-MLACP-COUNTERS {
      description
        "ICCP group mLACP counters";
      container connection {
        description
          "Number of connection events";
        uses BMD-BAG-MLACP-CONNECTION-COUNTERS;
      }  // container connection

      container tl-vs {
        description
          "Number TLVs sent and received";
        uses BMD-BAG-MLACP-RG-TLV-COUNTERS;
      }  // container tl-vs

      container invalid-tl-vs {
        description
          "Number invalid TLVs received";
        uses BMD-BAG-MLACP-INVALID-TLV-COUNTERS;
      }  // container invalid-tl-vs

      container iccp-messages {
        description
          "Number ICCP messages sent and received";
        uses BMD-BAG-MLACP-ICCP-MSG-COUNTERS;
      }  // container iccp-messages

      container iccp-events {
        description "Number of ICCP events";
        uses BMD-BAG-MLACP-ICCP-EVENT-COUNTERS;
      }  // container iccp-events

      leaf last-time-cleared {
        type uint64;
        units "nanosecond";
        description
          "Time in nsecs from boot when counters were last
         cleared (deprecated)";
      }

      leaf time-since-cleared {
        type uint64;
        units "nanosecond";
        description
          "Elapsed time in nsecs since counters were last
         cleared";
      }

      leaf last-unexpected-event {
        type uint64;
        units "nanosecond";
        description
          "Elapsed time in nsecs since last unexpected
         event";
      }
    }  // grouping BMD-BAG-RG-INFO-MLACP-COUNTERS

    grouping BMD-BAG-RG-INFO-MLACP-COUNTERS-RG {
      description
        "mLACP counter information for an ICCP group";
      container iccp-group-counters {
        description "ICCP Group counters";
        uses BMD-BAG-RG-INFO-MLACP-COUNTERS;
      }  // container iccp-group-counters

      leaf iccp-group-id {
        type uint32;
        description "ICCP Group ID";
      }
    }  // grouping BMD-BAG-RG-INFO-MLACP-COUNTERS-RG

    grouping BMD-EVENT-BAG-MULTIPLE {
      description
        "Bag for returning data about events";
      list events-item {
        description
          "Event items corresponding to bundle or member or
         RG";
        uses BMD-EVENT-BAG;
      }  // list events-item
    }  // grouping BMD-EVENT-BAG-MULTIPLE

    grouping BM-MAC-ALLOC {
      description
        "Data on MAC address allocation";
      list mac-address {
        description
          "MAC addresses allocated but unused";
        uses BM-MAC-ADDR-ST;
      }  // list mac-address
    }  // grouping BM-MAC-ALLOC

    grouping MLACP-MBR-INFO-TYPE {
      description "Information for a member";
      leaf port-name {
        type string;
        description "Port Name";
      }

      leaf interface-handle {
        type xr:Interface-name;
        description
          "Member's interface handle (local device's
         members only)";
      }

      leaf mlacp-node-id {
        type uint8;
        description "mLACP Device ID";
      }

      leaf port-number {
        type uint16;
        description
          "Port number of the member";
      }

      leaf operational-priority {
        type uint16;
        description
          "Operational priority of the member in the bundle";
      }

      leaf configured-priority {
        type uint16;
        description
          "Configured priority of the member in the bundle";
      }

      leaf member-state {
        type Bmd-mlacp-mbr-state-enum;
        description
          "State of the member of the bundle";
      }
    }  // grouping MLACP-MBR-INFO-TYPE

    grouping MLACP-BDL-INFO-TYPE {
      description "Information for a bundle";
      container mac-address {
        description "Bundle MAC address";
        uses BM-MAC-ADDR-ST;
      }  // container mac-address

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

      leaf mlacp-node-id {
        type uint8;
        description "mLACP Device ID";
      }

      leaf aggregator-id {
        type uint16;
        description "Bundle aggregrator ID";
      }

      leaf bundle-state {
        type Bmd-mlacp-bdl-state-enum;
        description "State of the bundle";
      }

      leaf port-priority {
        type uint16;
        description "Bundle port priority";
      }
    }  // grouping MLACP-BDL-INFO-TYPE

    grouping BMD-BAG-MLACP-BDL {
      description
        "mLACP information for a bundle";
      leaf bundle-interface-key {
        type uint16;
        description
          "Key of the bundle interface";
      }

      leaf media-type {
        type Bundle-media;
        description
          "The media type of the bundle interface";
      }

      leaf redundancy-object-id {
        type uint64;
        description
          "Redundancy Object ID of the bundle";
      }

      list mlacp-bundle-data {
        description
          "mLACP information for the bundle";
        uses MLACP-BDL-INFO-TYPE;
      }  // list mlacp-bundle-data

      list mlacp-member-data {
        description
          "mLACP information for the member";
        uses MLACP-MBR-INFO-TYPE;
      }  // list mlacp-member-data
    }  // grouping BMD-BAG-MLACP-BDL

    grouping MLACP-RG-NODE-INFO-TYPE {
      description
        "LACP information for an RG";
      container system-id {
        description
          "System ID for the ICCP Group";
        uses BM-SYSTEM-ID-TYPE;
      }  // container system-id

      leaf mlacp-node-id {
        type uint8;
        description "mLACP Device ID";
      }

      leaf ldp-id {
        type Bmd-node-ldp-id;
        description "LDP ID of the device";
      }

      leaf version-number {
        type uint32;
        description
          "Version of the protocol being used";
      }

      leaf node-state {
        type Bmd-mlacp-node-state-enum;
        description "State of the Node";
      }

      leaf iccp-group-state {
        type Bmd-mlacp-node-sync-enum;
        description
          "Node synchronization state";
      }
    }  // grouping MLACP-RG-NODE-INFO-TYPE

    grouping BMD-BAG-MLACP-RG {
      description
        "mLACP information for an RG";
      leaf iccp-group-id {
        type uint32;
        description
          "ICCP Group that the mLACP information is for";
      }

      leaf singleton {
        type boolean;
        description
          "Is the ICCP group in singleton mode (1 =
         singleton; 0 = not singleton)";
      }

      leaf connect-timer-running {
        type uint64;
        units "nanosecond";
        description
          "Time remaining on connect timer innsecs";
      }

      list node-data {
        description
          "Information for the IG from the local and peer
         devices";
        uses MLACP-RG-NODE-INFO-TYPE;
      }  // list node-data
    }  // grouping BMD-BAG-MLACP-RG

    grouping BMD-BAG-MLACP-DATA {
      description
        "Combined mLACP information for bundle and ICCP
       Group";
      container iccp-group-data {
        description "ICCP Group information";
        uses BMD-BAG-MLACP-RG;
      }  // container iccp-group-data

      list bundle-data {
        description "Bundle information";
        uses BMD-BAG-MLACP-BDL;
      }  // list bundle-data
    }  // grouping BMD-BAG-MLACP-DATA

    grouping BMD-BAG-MLACP-DATA-MULTIPLE {
      description
        "Combined mLACP information for bundle and ICCP
       Group";
      list mlacp-data {
        description
          "mLACP data for multiple ICCP Groups";
        uses BMD-BAG-MLACP-DATA;
      }  // list mlacp-data
    }  // grouping BMD-BAG-MLACP-DATA-MULTIPLE

    grouping BMD-BAG-PROT-MBR-INFO {
      description
        "Protect information for a member";
      leaf interface-handle {
        type xr:Interface-name;
        description
          "Member's interface handle";
      }

      leaf underlying-link-id {
        type uint16;
        description
          "Member's underlying link ID";
      }

      leaf link-order-number {
        type uint16;
        description
          "Member's link order number";
      }

      leaf bandwidth {
        type uint64;
        description "Member's bandwidth";
      }

      leaf node {
        type xr:Node-id;
        description "Member's node ID";
      }

      leaf active {
        type boolean;
        description
          "Member is active within its bundle";
      }

      leaf notification-received {
        type boolean;
        description
          "Received a notification on the member";
      }

      leaf slow-path-up {
        type boolean;
        description
          "Member is up in the slow path";
      }

      leaf time-stamp {
        type uint64;
        description
          "Last event for the member";
      }
    }  // grouping BMD-BAG-PROT-MBR-INFO

    grouping BMD-BAG-PROT-BDL-INFO {
      description
        "Protect information for a bundle";
      leaf bundle-interface-handle {
        type xr:Interface-name;
        description
          "Handle of the bundle interface";
      }

      leaf interface-up {
        type boolean;
        description
          "Whether the bundle interface is up";
      }

      leaf registered {
        type boolean;
        description
          "Whether there is a client protect registration
         on the bundle interface";
      }

      leaf slow-path-up {
        type boolean;
        description
          "Bundle is up in the slow path";
      }

      leaf slow-path-trigger {
        type boolean;
        description
          "Whether the last protect trigger originated in
         the slow path";
      }

      leaf minimum-active-links {
        type uint32;
        description
          "Minimum active links threshold";
      }

      leaf minimum-bandwidth {
        type uint64;
        description
          "Minimum bandwidth threshold";
      }

      leaf event-type {
        type Bmd-bag-target;
        description
          "Scope of the last event that impacted the bundle";
      }

      leaf time-stamp {
        type uint64;
        description
          "Last event for the bundle";
      }

      list member-info {
        description
          "Information about the members";
        uses BMD-BAG-PROT-MBR-INFO;
      }  // list member-info
    }  // grouping BMD-BAG-PROT-BDL-INFO

    grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG-MULTIPLE {
      description
        "mLACP counter information for multiple ICCP
       groups";
      list iccp-group {
        description
          "ICCP Group mLACP TLV counter information";
        uses BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG;
      }  // list iccp-group
    }  // grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG-MULTIPLE

    grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-NODE-DATA {
      description
        "Peer device specific mLACP TLV counter
       information";
      container mlacp-sync-requests-on-all-foreign-ports {
        description
          "Counts of mLACP sync request TLVs on all ports";
        uses OPTIONAL-SYNC-REQUEST-COUNTERS;
      }  // container mlacp-sync-requests-on-all-foreign-ports

      container mlacp-sync-requests-on-all-foreign-bundles {
        description
          "Counts of mLACP sync request TLVs on all bundles";
        uses OPTIONAL-SYNC-REQUEST-COUNTERS;
      }  // container mlacp-sync-requests-on-all-foreign-bundles

      leaf node-id {
        type uint32;
        description "Device ID";
      }
    }  // grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-NODE-DATA

    grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-NODE {
      description
        "Per peer device mLACP TLV counter information";
      container node-data {
        description
          "Peer device mLACP TLV counter information";
        uses BMD-BAG-BDL-INFO-MLACP-COUNTERS-NODE-DATA;
      }  // container node-data

      list bundle-data {
        description
          "Peer device bundle mLACP TLV counter information";
        uses BMD-BAG-BDL-INFO-MLACP-COUNTERS-BDL;
      }  // list bundle-data
    }  // grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-NODE

    grouping BMD-BAG-MLACP-SYNC-RQST-COUNTERS {
      description
        "Counts of mLACP sync request TLVs received";
      container received-sync-requests {
        description
          "Number of mLACP sync request TLVs received";
        uses BMD-BAG-MLACP-SYNC-RQST-TLVS-RCVD;
      }  // container received-sync-requests

      leaf last-time-cleared {
        type uint64;
        units "nanosecond";
        description
          "Time in nsecs from boot when counters were last
         cleared (deprecated)";
      }

      leaf time-since-cleared {
        type uint64;
        units "nanosecond";
        description
          "Elapsed time in nsecs since counters were last
         cleared";
      }
    }  // grouping BMD-BAG-MLACP-SYNC-RQST-COUNTERS

    grouping OPTIONAL-SYNC-REQUEST-COUNTERS {
      description
        "Optional sync request counters field";
      uses BMD-BAG-MLACP-SYNC-RQST-COUNTERS;
    }  // grouping OPTIONAL-SYNC-REQUEST-COUNTERS

    grouping BMD-BAG-MLACP-SYNC-RQST-TLVS-RCVD {
      description
        "Counts of mLACP sync request TLVs received";
      leaf all-syncs {
        type uint32;
        description
          "Total number of sync requests received";
      }

      leaf config-syncs {
        type uint32;
        description
          "Number of config sync requests received";
      }

      leaf state-syncs {
        type uint32;
        description
          "Number of state sync requests received";
      }
    }  // grouping BMD-BAG-MLACP-SYNC-RQST-TLVS-RCVD

    grouping BMD-BAG-MLACP-TLV-COUNTERS {
      description
        "Counts of mLACP TLVs sent and received";
      container received-sync-requests {
        description
          "Number of mLACP sync request TLVs received";
        uses BMD-BAG-MLACP-SYNC-RQST-TLVS-RCVD;
      }  // container received-sync-requests

      leaf sent-config-tl-vs {
        type uint32;
        description
          "Number of mLACP config TLVs sent";
      }

      leaf sent-state-tl-vs {
        type uint32;
        description
          "Number of mLACP state TLVs sent";
      }

      leaf sent-priority-tl-vs {
        type uint32;
        description
          "Number of mLACP priority TLVs sent";
      }

      leaf received-priority-tl-vs {
        type uint32;
        description
          "Number of mLACP priority TLVs received";
      }

      leaf received-nak-tl-vs {
        type uint32;
        description
          "Number of mLACP NAK TLVs received";
      }

      leaf last-time-cleared {
        type uint64;
        units "nanosecond";
        description
          "Time in nsecs from boot when counters were last
         cleared (deprecated)";
      }

      leaf time-since-cleared {
        type uint64;
        units "nanosecond";
        description
          "Elapsed time in nsecs since counters were last
         cleared";
      }

      leaf last-unexpected-event {
        type uint64;
        units "nanosecond";
        description
          "Elapsed time in nsecs since last unexpected
         event";
      }
    }  // grouping BMD-BAG-MLACP-TLV-COUNTERS

    grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-BDL {
      description
        "Per bundle mLACP TLV counter information";
      container mlacp-tlv-counters {
        description
          "Counts of mLACP TLVs sent and received";
        uses BMD-BAG-MLACP-TLV-COUNTERS;
      }  // container mlacp-tlv-counters

      leaf bundle-name {
        type string;
        description "Name of the bundle";
      }
    }  // grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-BDL

    grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG-DATA {
      description
        "ICCP group specific mLACP TLV counter information";
      container mlacp-sync-requests-on-all-local-ports {
        description
          "Counts of mLACP sync request TLVs on all ports";
        uses OPTIONAL-SYNC-REQUEST-COUNTERS;
      }  // container mlacp-sync-requests-on-all-local-ports

      container mlacp-sync-requests-on-all-local-bundles {
        description
          "Counts of mLACP sync request TLVs on all bundles";
        uses OPTIONAL-SYNC-REQUEST-COUNTERS;
      }  // container mlacp-sync-requests-on-all-local-bundles

      leaf iccp-group-id {
        type uint32;
        description "ICCP Group ID";
      }

      list bundle-data {
        description
          "Local device bundle mLACP counter information";
        uses BMD-BAG-BDL-INFO-MLACP-COUNTERS-BDL;
      }  // list bundle-data
    }  // grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG-DATA

    grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG {
      description
        "ICCP group mLACP counter information";
      container iccp-group-data {
        description
          "ICCP Group mLACP TLV counter information";
        uses BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG-DATA;
      }  // container iccp-group-data

      list node-data {
        description
          "Peer device bundle mLACP counter information";
        uses BMD-BAG-BDL-INFO-MLACP-COUNTERS-NODE;
      }  // list node-data
    }  // grouping BMD-BAG-BDL-INFO-MLACP-COUNTERS-RG

    grouping LACP-LINK-ADDITIONAL-INFO-FOREIGN-TYPE {
      description
        "Additional information for a foreign LACP link";
      leaf peer-address {
        type Bmd-node-ldp-id;
        description
          "The LDP address of the device that the link is
         configured on";
      }

      leaf member-name {
        type string;
        description
          "Member's (short form) name";
      }
    }  // grouping LACP-LINK-ADDITIONAL-INFO-FOREIGN-TYPE

    grouping LACP-LINK-ADDITIONAL-INFO-LOCAL-TYPE {
      description
        "Additional information for a local LACP link";
      leaf interface-handle {
        type xr:Interface-name;
        description
          "Member's interface handle";
      }
    }  // grouping LACP-LINK-ADDITIONAL-INFO-LOCAL-TYPE

    grouping LACP-LINK-ADDITIONAL-INFO {
      description
        "Additional information for the link that is
       dependent on type";
      container local {
        when "../mbr-type = 'bmd-mbr-local'" {
          description
            "../MbrType = 'BMD_MBR_LOCAL'";
        }
        description
          "Information for a local port";
        uses LACP-LINK-ADDITIONAL-INFO-LOCAL-TYPE;
      }  // container local

      container foreign {
        when
          "../mbr-type = 'bmd-mbr-foreign'" {
          description
            "../MbrType = 'BMD_MBR_FOREIGN'";
        }
        description
          "Information for a foreign port";
        uses LACP-LINK-ADDITIONAL-INFO-FOREIGN-TYPE;
      }  // container foreign

      leaf mbr-type {
        type Bmd-member-type-enum;
        description "MbrType";
      }
    }  // grouping LACP-LINK-ADDITIONAL-INFO

    grouping BM-LINK-ID-TYPE {
      description "BM LINK ID TYPE";
      leaf link-priority {
        type uint16;
        description "link priority";
      }

      leaf link-number {
        type Bm-link-number;
        description "link number";
      }
    }  // grouping BM-LINK-ID-TYPE

    grouping BM-LACP-PORT-INFO-TYPE {
      description "BM LACP PORT INFO TYPE";
      container system {
        description "system";
        uses BM-SYSTEM-ID-TYPE;
      }  // container system

      container port {
        description "port";
        uses BM-LINK-ID-TYPE;
      }  // container port

      leaf key {
        type Bm-bdl-id;
        description "key";
      }

      leaf state {
        type Bm-link-state-bits;
        description "state";
      }
    }  // grouping BM-LACP-PORT-INFO-TYPE

    grouping LACP-LINK-DEVICE-INFO-TYPE {
      description
        "Link properties for a port from a device";
      container port-info {
        description
          "LACP parameters for this device";
        uses BM-LACP-PORT-INFO-TYPE;
      }  // container port-info

      leaf tx-period {
        type Bm-link-period-value;
        description
          "Time (in ms) between transmitting LACPDUs";
      }
    }  // grouping LACP-LINK-DEVICE-INFO-TYPE

    grouping LACP-MBR-DATA {
      description
        "Link properties for a port using LACP";
      container actor-info {
        description
          "LACP information for the port from the actor";
        uses LACP-LINK-DEVICE-INFO-TYPE;
      }  // container actor-info

      container partner-info {
        description
          "LACP information for the port from the partner";
        uses LACP-LINK-DEVICE-INFO-TYPE;
      }  // container partner-info

      container additional-info {
        description
          "Additional information for the link";
        uses LACP-LINK-ADDITIONAL-INFO;
      }  // container additional-info

      leaf selected-aggregator-id {
        type uint32;
        description
          "MIB ifindex of selected bundle";
      }

      leaf attached-aggregator-id {
        type uint32;
        description
          "MIB ifindex of attached bundle";
      }

      leaf selection-state {
        type Lacp-sel-state;
        description
          "State of the Selection Logic state machine";
      }

      leaf period-state {
        type Lacp-period-state;
        description
          "State of the Period state machine";
      }

      leaf receive-machine-state {
        type Rxstates;
        description
          "State of the RX state machine";
      }

      leaf mux-state {
        type Bm-muxstate;
        description
          "State of the Mux state machine";
      }

      leaf actor-churn-state {
        type Lacp-churnstates;
        description
          "State of the Churn state machine for the Actor";
      }

      leaf partner-churn-state {
        type Lacp-churnstates;
        description
          "State of the Churn state machine for the Partner";
      }

      leaf iccp-group-id {
        type uint32;
        description
          "The ID of the ICCP group that the link is
         configured on";
      }
    }  // grouping LACP-MBR-DATA

    grouping LACP-COMBINED-DATA {
      description
        "Bag containing the bundle and member data with
       regard to outputting LACP data";
      container bundle-data {
        description "Bundle information";
        uses LACP-BUNDLE-DATA;
      }  // container bundle-data

      list member-data {
        description "Member information";
        uses LACP-MBR-DATA;
      }  // list member-data
    }  // grouping LACP-COMBINED-DATA

    grouping BMD-BAG-EVENT-ITEM-RG {
      description
        "A single event item for an RG";
      container data {
        description
          "Additional data for the event";
        uses BMD-BAG-EVENT-DATA;
      }  // container data

      leaf rg-event-type {
        type Bmd-bag-event-rg-item;
        description "Type of event for RG";
      }

      leaf time-stamp {
        type uint64;
        description
          "Time stamp of the event";
      }
    }  // grouping BMD-BAG-EVENT-ITEM-RG

    grouping BMD-BAG-EVENT-ITEM-BDL {
      description
        "A single event item for a bundle";
      container data {
        description
          "Additional data for the event";
        uses BMD-BAG-EVENT-DATA;
      }  // container data

      leaf bundle-event-type {
        type Bmd-bag-event-bdl-item;
        description
          "Type of event for bundle";
      }

      leaf time-stamp {
        type uint64;
        description
          "Time stamp of the event";
      }
    }  // grouping BMD-BAG-EVENT-ITEM-BDL

    grouping BMD-BAG-EVENT-DATA {
      description
        "Additional data for an event";
      leaf data-type {
        type Bmd-bag-event-data;
        description "DataType";
      }

      leaf no-data {
        when
          "../data-type = 'bmd-bag-evt-data-none'" {
          description
            "../DataType = 'BMD_BAG_EVT_DATA_NONE'";
        }
        type uint8;
        description "NoData";
      }

      leaf error {
        when
          "../data-type = 'bmd-bag-evt-data-error'" {
          description
            "../DataType = 'BMD_BAG_EVT_DATA_ERROR'";
        }
        type uint32;
        description "Error";
      }

      leaf string-data {
        when
          "../data-type = 'bmd-bag-evt-data-string'" {
          description
            "../DataType = 'BMD_BAG_EVT_DATA_STRING'";
        }
        type Bmd-bag-item-string;
        description "StringData";
      }
    }  // grouping BMD-BAG-EVENT-DATA

    grouping BMD-BAG-EVENT-ITEM-MBR {
      description
        "A single event item for a member";
      container data {
        description
          "Additional data for the event";
        uses BMD-BAG-EVENT-DATA;
      }  // container data

      leaf member-event-type {
        type Bmd-bag-event-mbr-item;
        description
          "Type of event for member";
      }

      leaf time-stamp {
        type uint64;
        description
          "Time stamp of the event";
      }
    }  // grouping BMD-BAG-EVENT-ITEM-MBR

    grouping BMD-BAG-EVENT-ITEM {
      description "Event item";
      container member-evt-info {
        when
          "../event-type = 'bm-bag-target-mbr'" {
          description
            "../EventType = 'BM_BAG_TARGET_MBR'";
        }
        description
          "Event information for a member";
        uses BMD-BAG-EVENT-ITEM-MBR;
      }  // container member-evt-info

      container bundle-evt-info {
        when
          "../event-type = 'bm-bag-target-bdl'" {
          description
            "../EventType = 'BM_BAG_TARGET_BDL'";
        }
        description
          "Event information for a bundle";
        uses BMD-BAG-EVENT-ITEM-BDL;
      }  // container bundle-evt-info

      container rg-evt-info {
        when
          "../event-type = 'bm-bag-target-rg'" {
          description
            "../EventType = 'BM_BAG_TARGET_RG'";
        }
        description
          "Event information for an RG";
        uses BMD-BAG-EVENT-ITEM-RG;
      }  // container rg-evt-info

      leaf event-type {
        type Bmd-bag-target;
        description "EventType";
      }
    }  // grouping BMD-BAG-EVENT-ITEM

    grouping BMD-EVENT-BAG {
      description
        "Bag for returning data about events";
      leaf item-name {
        type string;
        description
          "Name for the current item to use";
      }

      list items {
        description "Event items";
        uses BMD-BAG-EVENT-ITEM;
      }  // list items
    }  // grouping BMD-EVENT-BAG

    grouping BM-BUNDLE-COMBINED-DATA {
      description
        "Combined bundle and member data bags";
      container bundle-data {
        description "Bundle information";
        uses BM-BUNDLE-DATA;
      }  // container bundle-data

      list member-data {
        description "Member information";
        uses BM-MEMBER-DATA;
      }  // list member-data
    }  // grouping BM-BUNDLE-COMBINED-DATA

    grouping BMD-BAG-MLACP-SCH-ACTION {
      description
        "Bag for returning data about scheduled actions";
      leaf mlacp-action {
        type Bmd-bag-mlacp-sch-action-item;
        description
          "Type of mLACP scheduled action for a bundle";
      }

      leaf time-remaining {
        type uint64;
        units "second";
        description
          "Seconds left before action";
      }

      leaf action-state {
        type Bmd-switch-reason;
        description
          "Details whether the switch action is viable";
      }
    }  // grouping BMD-BAG-MLACP-SCH-ACTION

    grouping BMD-SCH-ACTION-BAG {
      description
        "Bag for returning data about scheduled actions";
      leaf bundle-name {
        type string;
        description "Name of the bundle";
      }

      list scheduled-action {
        description
          "Scheduled actions for mlacp in case of switch
         over";
        uses BMD-BAG-MLACP-SCH-ACTION;
      }  // list scheduled-action
    }  // grouping BMD-SCH-ACTION-BAG

    grouping BMD-BFD-COUNTER-BAG {
      description "BFD events";
      leaf member-name {
        type string;
        description
          "Name of the member this information is for";
      }

      leaf last-time-cleared {
        type uint64;
        description
          "Timestamp when counters were last cleared
         (deprecated)";
      }

      leaf starting {
        type uint32;
        description
          "Number of times member state changed to starting";
      }

      leaf up {
        type uint32;
        description
          "Number of times member state changed to up";
      }

      leaf down {
        type uint32;
        description
          "Number of times member state changed to down";
      }

      leaf neighbor-unconfigured {
        type uint32;
        description
          "Number of times member state changed to neighbor
         unconfigured";
      }

      leaf start-timeouts {
        type uint32;
        description
          "Number of timeouts waiting for BFD to start";
      }

      leaf neighbor-unconfigured-timeouts {
        type uint32;
        description
          "Number of timeouts waiting for neighbor to
         become unconfigured";
      }

      leaf time-since-cleared {
        type uint64;
        units "nanosecond";
        description
          "Elapsed time in nsecs since counters were last
         cleared";
      }
    }  // grouping BMD-BFD-COUNTER-BAG

    grouping BM-NAME-BAG {
      description "Item Name";
      leaf item-name {
        type string;
        description "Name of item";
      }
    }  // grouping BM-NAME-BAG

    grouping BMD-BFD-COUNTER-BAG-MULTIPLE {
      description "BFD events";
      container bundle-name {
        description
          "Name of the bundle this information is for";
        uses BM-NAME-BAG;
      }  // container bundle-name

      list bfd-counter {
        description "BFD event counters";
        uses BMD-BFD-COUNTER-BAG;
      }  // list bfd-counter
    }  // grouping BMD-BFD-COUNTER-BAG-MULTIPLE

    grouping BM-MBR-STATE-REASON-DATA-TYPE {
      description
        "Additional member state reason data";
      leaf reason-type {
        type Bm-state-reason-target;
        description
          "The item the reason applies to";
      }

      leaf severity {
        type Bm-severity;
        description
          "The severity of the reason";
      }
    }  // grouping BM-MBR-STATE-REASON-DATA-TYPE

    grouping BM-MUX-DATA {
      description "bm mux information";
      container member-mux-state-reason-data {
        description
          "Data regarding the reason for last Mux state
         change";
        uses BM-MBR-STATE-REASON-DATA-TYPE;
      }  // container member-mux-state-reason-data

      leaf mux-state {
        type Bm-muxstate;
        description
          "Current state of this bundle member";
      }

      leaf error {
        type uint32;
        description
          "Internal value indicating if an error occurred
         trying to put a link into the desired state";
      }

      leaf member-mux-state-reason {
        type Bm-mbr-state-reason;
        description
          "Reason for last Mux state change";
      }

      leaf member-state {
        type Bmd-member-state;
        description
          "Current internal state of this bundle member";
      }

      leaf mux-state-reason {
        type Bm-muxreason;
        description
          "Reason for last Mux state change (Deprecated)";
      }
    }  // grouping BM-MUX-DATA

    grouping BM-LACP-LINK-DATA {
      description
        "Link properties for a port using LACP ";
      leaf interface-handle {
        type xr:Interface-name;
        description
          "Member's interface handle";
      }

      leaf actor-system-priority {
        type uint16;
        description
          "System priority of actor system";
      }

      leaf actor-system-mac-address {
        type yang:mac-address;
        description
          "MAC Address of the actor system";
      }

      leaf actor-operational-key {
        type uint16;
        description
          "Operational key for this port";
      }

      leaf partner-system-priority {
        type uint16;
        description
          "System priority of partner system";
      }

      leaf partner-system-mac-address {
        type yang:mac-address;
        description
          "MAC Address used to identify the partner system";
      }

      leaf partner-operational-key {
        type uint16;
        description
          "Operational key for partner port";
      }

      leaf selected-aggregator-id {
        type uint32;
        description
          "MIB ifindex of selected bundle";
      }

      leaf attached-aggregator-id {
        type uint32;
        description
          "MIB ifindex of attached bundle";
      }

      leaf actor-port-id {
        type uint16;
        description
          "Port number of this port";
      }

      leaf actor-port-priority {
        type uint16;
        description "Priority of this port";
      }

      leaf partner-port-id {
        type uint16;
        description
          "Port number of the partner's port";
      }

      leaf partner-port-priority {
        type uint16;
        description
          "Priority of the partner's port";
      }

      leaf actor-port-state {
        type uint8;
        description
          "LACP state of this port";
      }

      leaf partner-port-state {
        type uint8;
        description
          "LACP state of the partner's port";
      }
    }  // grouping BM-LACP-LINK-DATA

    grouping BM-LACP-COUNTERS {
      description
        "Statistics for a port using using LACP";
      leaf lacpd-us-received {
        type uint32;
        description "LACPDUs received";
      }

      leaf lacpd-us-transmitted {
        type uint32;
        description "LACPDUs transmitted";
      }

      leaf marker-packets-received {
        type uint32;
        description
          "LACP Marker packets received";
      }

      leaf marker-responses-transmitted {
        type uint32;
        description
          "LACP Marker response packets transmitted";
      }

      leaf illegal-packets-received {
        type uint32;
        description
          "Illegal and unknown packets received";
      }

      leaf excess-lacpd-us-received {
        type uint32;
        description
          "LACPDUs received that exceed the rate limit";
      }

      leaf excess-marker-packets-received {
        type uint32;
        description
          "Marker packets received that exceed the rate
         limit";
      }

      leaf defaulted {
        type uint32;
        description
          "State flag set to Defaulted";
      }

      leaf expired {
        type uint32;
        description
          "State flag set to Expired";
      }

      leaf last-cleared-sec {
        type uint32;
        description
          "Last time counters cleared (s) (deprecated)";
      }

      leaf last-cleared-nsec {
        type uint32;
        description
          "Last time counters cleared (nsec) (deprecated)";
      }
    }  // grouping BM-LACP-COUNTERS

    grouping BM-MEMBER-DATA {
      description
        "Bundle member data for any member";
      container counters {
        description
          "Counters data about member link";
        uses BM-LACP-COUNTERS;
      }  // container counters

      container link-data {
        description
          "Lacp data about member link";
        uses BM-LACP-LINK-DATA;
      }  // container link-data

      container member-mux-data {
        description "Mux state machine data";
        uses BM-MUX-DATA;
      }  // container member-mux-data

      container mac-address {
        description
          "MAC address of this member (deprecated)";
        uses BM-MAC-ADDR-ST;
      }  // container mac-address

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

      leaf port-priority {
        type uint16;
        description
          "The priority of this member";
      }

      leaf port-number {
        type uint16;
        description "Member's link number";
      }

      leaf underlying-link-id {
        type uint16;
        description
          "Member's underlying link ID";
      }

      leaf link-order-number {
        type uint16;
        description
          "Member's link order number";
      }

      leaf iccp-node {
        type uint32;
        description "Location of member";
      }

      leaf bandwidth {
        type uint32;
        units "kbit/s";
        description
          "Bandwidth of this member (kbps)";
      }

      leaf lacp-enabled {
        type string;
        description
          "Boolean indicating LACP enabled or not";
      }

      leaf member-type {
        type Bmd-member-type-enum;
        description
          "Member's type (local/foreign)";
      }

      leaf member-name {
        type string;
        description
          "Member's (short form) name";
      }

      leaf replication-error {
        type uint32;
        description
          "Error from final replication attempt";
      }

      leaf bandwidth64-bit {
        type uint64;
        units "kbit/s";
        description
          "Bandwidth of this member 64-Bit (kbps)";
      }
    }  // grouping BM-MEMBER-DATA

    grouping ETHER-MACADDR-TYPE {
      description "ETHER MACADDR TYPE";
      leaf macaddr {
        type yang:hex-string;
        description "macaddr";
      }
    }  // grouping ETHER-MACADDR-TYPE

    grouping BM-SYSTEM-ID-TYPE {
      description "BM SYSTEM ID TYPE";
      container system-mac-addr {
        description
          "MAC Address used to identify the system";
        uses ETHER-MACADDR-TYPE;
      }  // container system-mac-addr

      leaf system-prio {
        type uint16;
        description "Priority of the system";
      }
    }  // grouping BM-SYSTEM-ID-TYPE

    grouping BM-ADDR {
      description
        "Union to store the different addresses for
       different address types";
      leaf af {
        type Bm-af-id;
        description "AF";
      }

      leaf ipv4 {
        when "../af = 'bm-af-id-ipv4'" {
          description
            "../AF = 'BM_AF_ID_IPV4'";
        }
        type Bm-in4-addr;
        description "IPv4 address type";
      }

      leaf ipv6 {
        when "../af = 'bm-af-id-ipv6'" {
          description
            "../AF = 'BM_AF_ID_IPV6'";
        }
        type Bm-in6-addr;
        description "IPv6 address type";
      }
    }  // grouping BM-ADDR

    grouping BM-BUNDLE-BFD-DATA-TYPE {
      description
        "BFD information of the bundle";
      container destination-address {
        description
          "Configured destination address for BFD session";
        uses BM-ADDR;
      }  // container destination-address

      leaf bundle-status {
        type Bmd-bfd-bdl-state;
        description
          "Status of BFD on the bundle";
      }

      leaf start-timer {
        type uint32;
        description
          "Time to wait on session start before declaring
         DOWN";
      }

      leaf nbr-unconfig-timer {
        type uint32;
        description
          "Time to wait on session NBR_UNCONFIG before
         declaring DOWN";
      }

      leaf pref-multiplier {
        type uint16;
        description
          "Preferred multiplier for the BFD session";
      }

      leaf pref-min-interval {
        type uint32;
        description
          "Preferred minimum interval for the BFD session
         (ms)";
      }

      leaf pref-echo-min-interval {
        type uint32;
        description
          "Preferred echo minimum interval for the BFD
         session (ms)";
      }

      leaf fast-detect {
        type boolean;
        description
          "Flag indicating if BFD is enabled (1 = enabled;
         0 = not enabled)";
      }

      leaf mode-info {
        type uint32;
        description
          "Standard used for per-member BFD";
      }
    }  // grouping BM-BUNDLE-BFD-DATA-TYPE

    grouping BM-MAC-ADDR-ST {
      description
        "Data on MAC address allocation";
      leaf address {
        type yang:mac-address;
        description "MAC address";
      }
    }  // grouping BM-MAC-ADDR-ST

    grouping BM-BUNDLE-DATA {
      description
        "Data for a bundle interface";
      container mac-address {
        description
          "MAC address of this member";
        uses BM-MAC-ADDR-ST;
      }  // container mac-address

      leaf bundle-interface-name {
        type xr:Interface-name;
        description
          "Name of the Bundle Interface";
      }

      leaf available-bandwidth {
        type uint64;
        units "kbit/s";
        description
          "Bandwidth available to the bundle interface
         (kbps)";
      }

      leaf effective-bandwidth {
        type uint64;
        units "kbit/s";
        description
          "Effective bandwidth on the bundle interface
         (kbps)";
      }

      leaf configured-bandwidth {
        type uint64;
        units "kbit/s";
        description
          "Bandwidth configured on the bundle interface
         (kbps)";
      }

      leaf minimum-active-links {
        type uint8;
        description
          "Minimum number of active links for bundle to go
         up";
      }

      leaf maximum-active-links {
        type uint8;
        description
          "Maximum number of active links in the bundle";
      }

      leaf maximum-active-links-source {
        type Bm-which-system;
        description
          "Source of maximum active links value";
      }

      leaf minimum-bandwidth {
        type uint64;
        units "kbit/s";
        description
          "Minimum bundle bandwidth for bundle to go up
         (kbps)";
      }

      leaf primary-member {
        type xr:Interface-name;
        description
          "Primary bundle member (no longer applicable)";
      }

      leaf bundle-status {
        type Bm-bdl-state;
        description
          "The state of the bundle";
      }

      leaf active-member-count {
        type uint16;
        description
          "The number of active local members on the bundle";
      }

      leaf standby-member-count {
        type uint16;
        description
          "The number of standby local members on the
         bundle";
      }

      leaf configured-member-count {
        type uint16;
        description
          "The number of configured local members on the
         bundle";
      }

      leaf mac-source {
        type Bm-bdl-mac-source;
        description
          "The source of the MAC Address";
      }

      leaf mac-source-member {
        type xr:Interface-name;
        description
          "The name of the member that supplied the MAC
         address";
      }

      leaf inter-chassis {
        type boolean;
        description
          "Indicates if this bundle is operating as an
         inter-chassis link (1 = I-C link, 0 = normal)";
      }

      leaf is-active {
        type boolean;
        description
          "Indicates the active/standby redundancy state of
         the device for the bundle";
      }

      leaf lacp-status {
        type Bm-feature-status;
        description
          "The status of the LACP feature on the bundle";
      }

      leaf mlacp-status {
        type Bm-feature-status;
        description
          "The status of the mLACP feature on the bundle";
      }

      leaf ipv4bfd-status {
        type Bm-feature-status;
        description
          "The status of the BFD (IPv4) feature on the
         bundle";
      }

      leaf link-order-status {
        type Bm-feature-status;
        description
          "The status of the link order signaling feature
         on the bundle";
      }

      leaf ipv6bfd-status {
        type Bm-feature-status;
        description
          "The status of the BFD (IPv6) feature on the
         bundle";
      }

      leaf load-balance-hash-type {
        type string;
        description
          "The type of hash to use for load balancing";
      }

      leaf load-balance-locality-threshold {
        type uint16;
        description
          "The number of links required per rack for
         localized load balancing";
      }

      leaf suppression-timer {
        type uint16;
        description
          "Timer for suppressing bundle state flaps";
      }

      leaf wait-while-timer {
        type uint16;
        description
          "The wait while time used for member ports";
      }

      leaf collector-max-delay {
        type uint16;
        units "microsecond";
        description
          "The maximum delay (in tens of microseconds) that
         the destination system can introduce between
         receiving a frame from a port and either
         delivering it to the MAC Client or discarding it";
      }

      leaf cisco-extensions {
        type boolean;
        description
          "The status of the Cisco Extensions feature (1 =
         enabled, 0 = not enabled)";
      }

      leaf lacp-nonrevertive {
        type boolean;
        description
          "The status of the LACP nonrevertive feature (1 =
         enable, 0 = not enabled)";
      }

      leaf iccp-group-id {
        type uint32;
        description
          "ICCP Group that the bundle is configured to";
      }

      leaf active-foreign-member-count {
        type uint16;
        description
          "The number of active foreign members on the
         bundle";
      }

      leaf configured-foreign-member-count {
        type uint16;
        description
          "The number of configured local members on the
         bundle";
      }

      leaf switchover-type {
        type Bmd-mlacp-switchover;
        description
          "How a switchover of the bundle from this device
         will occur";
      }

      leaf maximize-threshold-value-links {
        type uint32;
        description
          "Attempt to maximize the bundle if links are
         below this value";
      }

      leaf maximize-threshold-value-band-width {
        type uint64;
        description
          "Attempt to maximize the bundle if bandwidth is
         below this value";
      }

      leaf mlacp-mode {
        type Bundle-mlacp-mode;
        description
          "Indicates the mode of the device for the bundle";
      }

      leaf recovery-delay {
        type uint16;
        units "second";
        description
          "Number of seconds to wait before becoming active
         after recovering from a failure";
      }

      leaf singleton {
        type boolean;
        description
          "Is the ICCP group of the bundle in singleton
         mode (1 = singleton; 0 = not singleton)";
      }

      list bfd-config {
        description
          "Configuration values for BFD on bundle members";
        uses BM-BUNDLE-BFD-DATA-TYPE;
      }  // list bfd-config
    }  // grouping BM-BUNDLE-DATA

    grouping LACP-BUNDLE-DATA {
      description
        "Data for a LACP-enabled bundle interface";
      container actor-bundle-data {
        description
          "Basic bundle information";
        uses BM-BUNDLE-DATA;
      }  // container actor-bundle-data

      container bundle-system-id {
        description
          "System ID for the bundle";
        uses BM-SYSTEM-ID-TYPE;
      }  // container bundle-system-id

      leaf actor-operational-key {
        type uint16;
        description
          "Operational key of the interface";
      }

      leaf partner-system-priority {
        type uint16;
        description
          "Priority of the partner system";
      }

      leaf partner-system-mac-address {
        type yang:mac-address;
        description
          "MAC Address used to identify the partner system";
      }

      leaf partner-operational-key {
        type uint16;
        description
          "Operational key of the partner";
      }

      leaf applied-lacp-mode {
        type Bmd-lacp-mode;
        description "Applied LACP Mode";
      }
    }  // grouping LACP-BUNDLE-DATA
  }  // submodule Cisco-IOS-XR-bundlemgr-oper-sub2