submodule Cisco-IOS-XR-mld-oper-sub1 {

    yang-version 1;

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

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

    organization "Cisco Systems, Inc.";

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

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

    revision "2021-05-17" {
      description
        "Added DVMRP packet counter tracking for malloc and free.
       2020-10-13
         Depreciated to Cisco-IOS-XR-mld-oper
       2020-10-13
         Added DVMRP packet counter tracking for malloc and free.";
    }

    revision "2019-08-27" {
      description
        "Initial IOS-XR MLD native model";
    }

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

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

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

    typedef Igmp-edm-protocol {
      type enumeration {
        enum "no-route" {
          value 0;
          description "no route";
        }
        enum "sm" {
          value 1;
          description "sm";
        }
        enum "dm" {
          value 2;
          description "dm";
        }
        enum "bidir" {
          value 3;
          description "bidir";
        }
        enum "ssm" {
          value 4;
          description "ssm";
        }
        enum "any" {
          value 6;
          description "any";
        }
      }
      description "IGMP Protocol";
    }

    typedef Ipv6-address {
      type inet:ipv6-address;
      description "IPV6 Address type";
    }

    typedef Igmp-afi {
      type enumeration {
        enum "ipv4-unicast" {
          value 0;
          description "IP v4 unicast";
        }
        enum "ipv6-unicast" {
          value 1;
          description "IP v6 unicast";
        }
      }
      description "Address family";
    }

    typedef Im-state {
      type uint32;
      description "Im state";
    }

    grouping IGMP-EDM-NSF-BAG {
      description "IGMP NSF state";
      leaf is-multicast-nsf-active {
        type boolean;
        description
          "Is Multicast NSF active";
      }

      leaf multicast-nsf-timeout {
        type uint32;
        units "second";
        description
          "Multicast NSF timeout in secs";
      }

      leaf multicast-nsf-time-left {
        type uint32;
        units "second";
        description
          "Multicast NSF time remaining in secs";
      }

      leaf respawn-count {
        type uint32;
        description "Respawn Count";
      }

      leaf last-nsf-on {
        type int64;
        description "Last NSF time ON";
      }

      leaf last-nsf-off {
        type int64;
        description "Last NSF time off";
      }

      leaf last-nsf-on-min {
        type int32;
        units "second";
        description
          "Last NSF time ON in Seconds";
      }

      leaf last-nsf-off-min {
        type int32;
        units "second";
        description
          "Last NSF time OFF in Seconds";
      }

      leaf last-icd-notif-recv {
        type int64;
        description "Last ICD Notif Recv";
      }

      leaf last-icd-notif-recv-min {
        type int32;
        units "second";
        description
          "Last ICD Notif Recv in Seconds";
      }
    }  // grouping IGMP-EDM-NSF-BAG

    grouping IGMP-EDM-BVI-STATS-BAG {
      description "IGMP EDM BVI STATS BAG";
      leaf receive-buffers {
        type uint32;
        description
          "Number of AIPC buffers received";
      }

      leaf release-buffers {
        type uint32;
        description
          "Number of AIPC buffers released";
      }

      leaf send-blocks {
        type uint32;
        description
          "Number of AIPC buffers send blocked";
      }

      leaf release-fail-buffers {
        type uint32;
        description
          "Number of AIPC buffers release failed";
      }

      leaf null-buffer-handles {
        type uint32;
        description
          "Number of AIPC NULL buffer handles";
      }

      leaf rx-ipc-open-notif {
        type uint32;
        description
          "Number of AIPC open notifications received";
      }

      leaf rx-ipc-close-notif {
        type uint32;
        description
          "Number of AIPC close notifications received";
      }

      leaf rx-ipc-error-notif {
        type uint32;
        description
          "Number of AIPC error notifications received";
      }

      leaf rx-ipc-lwm-notif {
        type uint32;
        description
          "Number of AIPC LWM notifications received";
      }

      leaf rx-ipc-hwm-notif {
        type uint32;
        description
          "Number of AIPC HWM notifications received";
      }

      leaf rx-ipc-input-wait-notif {
        type uint32;
        description
          "Number of AIPC input waiting notifications
         received";
      }

      leaf rx-ipc-send-status-notif {
        type uint32;
        description
          "Number of AIPC send status notifications
         received";
      }

      leaf rx-ipc-publish-notif {
        type uint32;
        description
          "Number of AIPC publish notifications received";
      }

      leaf rx-ipc-q-full-notif {
        type uint32;
        description
          "Number of AIPC queue full notifications received";
      }

      leaf rx-ipc-output-notif {
        type uint32;
        description
          "Number of AIPC output notifications received";
      }

      leaf rx-ipc-connect-notif {
        type uint32;
        description
          "Number of AIPC connect notifications received";
      }

      leaf rx-igmp-packet-success {
        type uint32;
        description
          "Number of IGMP protocol messages received";
      }

      leaf rx-add-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Add messages received";
      }

      leaf rx-delete-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Delete messages received";
      }

      leaf rx-sweep-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Sweep messages received";
      }

      leaf tx-add-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Add messages transmitted";
      }

      leaf tx-delete-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Delete messages
         transmitted";
      }

      leaf tx-sweep-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Sweep messages received";
      }

      leaf rx-unknown-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Unknown messages received";
      }

      leaf tx-unknown-mrouter-msg {
        type uint32;
        description
          "Number of IGMP Mrouter Unknown messages
         transmitted";
      }

      leaf tx-buffer-errors {
        type uint32;
        description
          "Number of AIPC transmission errors";
      }

      leaf tx-buffers {
        type uint32;
        description
          "Number of AIPC buffers transmited";
      }

      leaf tx-protocol-buffers {
        type uint32;
        description
          "Number of IGMP protocol buffers transmitted";
      }

      leaf tx-mrouter-buffers {
        type uint32;
        description
          "Number of IGMP Mrouter buffers transmitted";
      }

      leaf tx-unknown-buffers {
        type uint32;
        description
          "Number of IGMP Unknown buffers transmited";
      }

      leaf wtx-msg-recvd {
        type uint32;
        description
          "Number of WTX messages received";
      }

      leaf wtx-msg-sent {
        type uint32;
        description
          "Number of WTX messages sent";
      }

      leaf wtx-msg-proto-sent {
        type uint32;
        description
          "Number of WTX messages sent to Protocol";
      }

      leaf wtx-msg-drop-dc {
        type uint32;
        description
          "Number of WTX messages dropped due to disconnect";
      }

      leaf wtx-msg-drop-nomem {
        type uint32;
        description
          "Number of WTX messages dropped to memory";
      }

      leaf wtx-msg-freed {
        type uint32;
        description
          "Number of WTX messages freed";
      }
    }  // grouping IGMP-EDM-BVI-STATS-BAG

    grouping IGMP-EDM-I2Q-STATS-BAG {
      description "IGMP Rate Adjust Stats";
      leaf queues {
        type uint16;
        description "I2Q Queue count";
      }

      leaf batches {
        type uint16;
        description "I2Q Rate Batch count";
      }

      leaf add-to-batches {
        type uint32;
        description "Add to batch count";
      }

      leaf delete-to-batches {
        type uint32;
        description "Delete to batch count";
      }

      leaf send-success {
        type uint32;
        description "Send Success count";
      }

      leaf send-errors {
        type uint32;
        description
          "Number of Send errors in batch";
      }

      leaf send-comm-errors {
        type uint32;
        description
          "Send Error due to comms count";
      }

      leaf send-partial-errors {
        type uint32;
        description
          "Send Error due to partial issue count";
      }

      leaf received-resync-requests {
        type uint32;
        description
          "Number of Resync request received";
      }

      leaf sent-resync-bulks {
        type uint32;
        description
          "Number of bulks sent for last resync received";
      }

      leaf is-resync-received {
        type boolean;
        description
          "Is Resync request received";
      }

      leaf is-resync-required {
        type boolean;
        description "Is Resync required";
      }

      leaf is-resync-start-sent {
        type boolean;
        description
          "Is Resync Start message sent";
      }

      leaf is-qos-s-sweeped {
        type boolean;
        description "Is QOS Sweeped once ";
      }

      leaf last-sweep-time {
        type uint64;
        units "second";
        description
          "Time elapsed since Last mark and sweep in
         seconds";
      }

      leaf last-download-time {
        type uint64;
        units "second";
        description
          "Time elapsed since Last download to QOS in
         seconds";
      }
    }  // grouping IGMP-EDM-I2Q-STATS-BAG

    grouping AMT-GW-BAG {
      description "AMT GW info";
      leaf amtgw {
        type inet:ipv4-address;
        description "GW";
      }

      leaf amt-port {
        type uint32;
        description "Port";
      }

      leaf key-len {
        type uint32;
        description "Len";
      }

      leaf amtnh {
        type uint32;
        description "AMT NH";
      }

      leaf amt-nonce {
        type uint32;
        description "Nonce";
      }

      leaf idb {
        type uint64;
        description "IDB";
      }

      leaf mem-upd-in {
        type uint32;
        description "UpdIn";
      }

      leaf mem-upd-out {
        type uint32;
        description "UpdOut";
      }
    }  // grouping AMT-GW-BAG

    grouping IGMP-EDM-NSR-BAG {
      description "IGMP NSR state";
      leaf state {
        type uint8;
        description "NSR state";
      }

      leaf partner-proc-connected {
        type boolean;
        description
          "Partner process connected";
      }

      leaf collab-conv-done {
        type boolean;
        description
          "Collaborators convergence done";
      }

      leaf rmf-notification-done {
        type boolean;
        description "RMF Notification done";
      }

      leaf last-proc {
        type uint64;
        description
          "Time when process came up";
      }

      leaf last-proc-connection-up {
        type uint64;
        description
          "Time when process connection went up";
      }

      leaf last-proc-connection-dn {
        type uint64;
        description
          "Time when process connection went down";
      }

      leaf last-rmf-ready {
        type uint64;
        description
          "Time when RMF Rdy notif was sent";
      }

      leaf last-rmf-not-ready {
        type uint64;
        description
          "Time when RMF Not-Rdy notif was sent";
      }

      leaf count-proc-connection-up {
        type uint32;
        description
          "No. of times process connection went up";
      }

      leaf count-proc-connection-dn {
        type uint32;
        description
          "No. of times process connection went down";
      }

      leaf count-rmf-ready {
        type uint32;
        description
          "No. of times RMF Ready notif was sent";
      }

      leaf count-rmf-not-ready {
        type uint32;
        description
          "No. of times RMF Not Ready notif was sent";
      }
    }  // grouping IGMP-EDM-NSR-BAG

    grouping AMT-SUMMARY-BAG {
      description "AMT summary info";
      leaf anycast-prefix {
        type inet:ipv4-address;
        description "Robustness variable";
      }

      leaf prefix-length {
        type uint32;
        description
          "Advertize AMT prefix length";
      }

      leaf relay-address {
        type inet:ipv4-address;
        description
          "Advertaisment for AMT Relay address";
      }

      leaf mtu {
        type uint32;
        description "AMT Tunnel MTU";
      }

      leaf tos {
        type uint32;
        description
          "Type Of Service value in AMT header";
      }

      leaf ttl {
        type uint32;
        description
          "Time To Live value in AMT header";
      }

      leaf query-interval {
        type uint32;
        description "AMT Query interval";
      }

      leaf gateway-count {
        type uint32;
        description "Number of AMT Gateway";
      }

      leaf max-gateway {
        type uint32;
        description
          "Maximum Gateway allowed";
      }

      leaf tunnel-count {
        type uint32;
        description "AMT Tunnel Count";
      }

      leaf tunnel-configured-maximum {
        type uint32;
        description
          "AMT Tunnel configured Maximum";
      }

      leaf is-acl-configured {
        type boolean;
        description
          "ACL configured under AMT";
      }

      leaf is-gateway-simulation {
        type boolean;
        description "AMT Gateway Simulation";
      }

      leaf is-ou-of-resource {
        type boolean;
        description "AMT Out Of Resource";
      }
    }  // grouping AMT-SUMMARY-BAG

    grouping IGMP-EDM-SSM-MAP-DETAIL-BAG {
      description "IGMP SSM Map Detail List";
      container map-info {
        description "Basic Map Info";
        uses IGMP-EDM-SSM-MAP-BAG;
      }  // container map-info

      leaf expiration-time {
        type uint32;
        units "second";
        description
          "Expiration Time in Seconds";
      }

      leaf response-pending {
        type boolean;
        description "Response Pending";
      }

      leaf query-interval {
        type uint32;
        description "Query interval";
      }

      leaf elapsed-time {
        type uint64;
        description "Elapsed time";
      }

      list sources {
        description "List of sources";
        uses IGMP-ADDRTYPE;
      }  // list sources
    }  // grouping IGMP-EDM-SSM-MAP-DETAIL-BAG

    grouping IGMP-EDM-IDB-SUMM-BAG {
      description
        "IGMP Interface DB summary";
      leaf interface-count {
        type uint32;
        description "Interface Count";
      }

      leaf configuration-count {
        type uint32;
        description "Configuration count";
      }
    }  // grouping IGMP-EDM-IDB-SUMM-BAG

    grouping IGMP-EDM-GROUPS-SUMMARY-BAG {
      description "IGMP group summary entry";
      leaf groutes {
        type uint32;
        description "No. of (*,G) routes";
      }

      leaf sg-routes {
        type uint32;
        description "No. of (S,G) routes";
      }

      leaf group-count {
        type uint32;
        description
          "Current groups accepted";
      }

      leaf is-low-memory {
        type boolean;
        description
          "Node is running low on memory";
      }
    }  // grouping IGMP-EDM-GROUPS-SUMMARY-BAG

    grouping IGMP-EDM-TRAFFIC-BAG {
      description
        "IGMP Traffic Counters bag";
      leaf elapsed-time {
        type uint32;
        description
          "Running time for counters";
      }

      leaf packets-in {
        type uint32;
        description "Packets in";
      }

      leaf packets-out {
        type uint32;
        description "Packets out";
      }

      leaf format-errors {
        type uint32;
        description "Malformed packets in";
      }

      leaf packet-manager-input-errors {
        type uint32;
        description
          "Incoming Packet Manager packets dropped";
      }

      leaf packet-manager-output-errors {
        type uint32;
        description
          "Outgoing Packet Manager packets dropped";
      }

      leaf checksum-errors {
        type uint32;
        description "Checksum errors";
      }

      leaf receive-socket-errors {
        type uint32;
        description
          "Socket errors on reception";
      }

      leaf socket-errors {
        type uint32;
        description "Socket errors on send";
      }

      leaf bad-scope-errors {
        type uint32;
        description "BadScope errors";
      }

      leaf auxillary-data-length-errors {
        type uint32;
        description "AuxDataLen errors";
      }

      leaf invalid-source-address-errors {
        type uint32;
        description
          "Invalid Source Address errors";
      }

      leaf no-socket-connection {
        type uint32;
        description
          "Packets dropped since no socket connection";
      }

      leaf miscellaneous-errors {
        type uint32;
        description
          "Packets dropped for other reasons";
      }

      leaf input-queries {
        type uint32;
        description "Query packets in";
      }

      leaf input-reports {
        type uint32;
        description "Reports in";
      }

      leaf input-leaves {
        type uint32;
        description "Leaves in";
      }

      leaf input-mtrace {
        type uint32;
        description "Mtrace packets in";
      }

      leaf input-dvmrp {
        type uint32;
        description "DVMRP packets in";
      }

      leaf dvmrp-alloc {
        type uint32;
        description
          "DVMRP buffer allocations";
      }

      leaf dvmrp-free {
        type uint32;
        description "DVMRP freed buffers";
      }

      leaf dvmrp-drop {
        type uint32;
        description "DVMRP packets dropped";
      }

      leaf input-pim {
        type uint32;
        description "PIM packets in";
      }

      leaf output-queries {
        type uint32;
        description "Query packets out";
      }

      leaf output-reports {
        type uint32;
        description "Reports out";
      }

      leaf output-leaves {
        type uint32;
        description "Leaves out";
      }

      leaf output-mtrace {
        type uint32;
        description "Mtrace packets out";
      }

      leaf output-dvmrp {
        type uint32;
        description "DVMRP packets out";
      }

      leaf output-pim {
        type uint32;
        description "PIM packets out";
      }

      leaf get-packet-failure {
        type uint32;
        description "Packet get failed";
      }

      leaf output-no-parent-interface-handle {
        type uint32;
        description
          "Failures setting 2nd ifhandle";
      }

      leaf input-no-idb {
        type uint32;
        description
          "Packets received without idb";
      }

      leaf input-no-vrf-in-idb {
        type uint32;
        description
          "Packets received on idb without VRF";
      }

      leaf input-disabled-idb {
        type uint32;
        description
          "Packet received on disabled idb";
      }

      leaf input-martian-address {
        type uint32;
        description
          "Packets received with Martian Address";
      }

      leaf input-no-assigned-vrf-id {
        type uint32;
        description
          "Packets received with no assigned vrf id";
      }

      leaf input-no-vrf-mtrace {
        type uint32;
        description
          "mtrace packets with no vrf associated";
      }

      leaf input-no-platform-support-mtrace {
        type uint32;
        description
          "mtrace packets without platform support";
      }

      leaf packet-allocated {
        type uint32;
        description
          "Number of pak allocated by IGMP";
      }

      leaf packet-freed {
        type uint32;
        description
          "Number of pak freed by IGMP";
      }
    }  // grouping IGMP-EDM-TRAFFIC-BAG

    grouping IGMP-EDM-IDB-IFRS-BAG {
      description
        "IGMP IFRS interface entry";
      container igmp-interface-entry {
        description "IGMP interface entry";
        uses IGMP-EDM-IDB-BAG;
      }  // container igmp-interface-entry

      leaf join-group-count {
        type uint32;
        description "Join group count";
      }
    }  // grouping IGMP-EDM-IDB-IFRS-BAG

    grouping IGMP-GROUP-RANGE {
      description "IGMP Group-Map Range";
      container group-address-xr {
        description "Group address";
        uses IGMP-ADDRTYPE;
      }  // container group-address-xr

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

      leaf protocol {
        type Igmp-edm-protocol;
        description "Protocol";
      }

      leaf is-stale {
        type boolean;
        description "Is the entry stale";
      }
    }  // grouping IGMP-GROUP-RANGE

    grouping IGMP-EDM-I2Q-INTF-RATE-BAG {
      description "IGMP-QOS Interface Rate";
      container source-address {
        description "Source address";
        uses IGMP-ADDRTYPE;
      }  // container source-address

      container group-address {
        description "Group address";
        uses IGMP-ADDRTYPE;
      }  // container group-address

      leaf is-add {
        type boolean;
        description
          "Is this a rate increment";
      }

      leaf weight {
        type uint32;
        description "Weight from policy";
      }

      leaf received-time {
        type uint64;
        description
          "Time this update is received";
      }
    }  // grouping IGMP-EDM-I2Q-INTF-RATE-BAG

    grouping IGMP-EDM-I2Q-INTF-STATS-BAG {
      description "IGMP-QOS Interface Stats";
      leaf is-virtual-access {
        type boolean;
        description
          "Is VirtualAccess Interface";
      }

      leaf rate {
        type uint32;
        units "kbit/s";
        description "Overall rate in Kbps";
      }

      leaf rate-increments {
        type uint32;
        description
          "Count of rate increments";
      }

      leaf rate-decrements {
        type uint32;
        description
          "Count of rate decrements";
      }

      list update {
        max-elements 5;
        description "List of updates";
        uses IGMP-EDM-I2Q-INTF-RATE-BAG;
      }  // list update
    }  // grouping IGMP-EDM-I2Q-INTF-STATS-BAG

    grouping IGMP-EDM-GROUPS-HOST-BAG {
      description "IGMP Groups host entry";
      container address {
        description "Host Address";
        uses IGMP-ADDRTYPE;
      }  // container address

      leaf uptime {
        type uint32;
        units "second";
        description "Uptime in seconds";
      }

      leaf is-exclude {
        type boolean;
        description "Exclude flag set";
      }

      leaf expiration-time {
        type uint32;
        units "second";
        description
          "Expiration time in seconds";
      }

      leaf source-count {
        type uint32;
        description
          "No. of sources in entry";
      }

      list source-address {
        max-elements 3;
        description
          "First 3 source addresses";
        uses IGMP-ADDRTYPE;
      }  // list source-address
    }  // grouping IGMP-EDM-GROUPS-HOST-BAG

    grouping IGMP-EDM-GROUPS-ET-BAG {
      description
        "IGMP group explicit-tracking entry";
      container group-info {
        description
          "Basic Group information";
        uses IGMP-EDM-GROUPS-BAG;
      }  // container group-info

      leaf include-hosts {
        type uint32;
        description
          "No. of hosts who are included";
      }

      leaf exclude-hosts {
        type uint32;
        description
          "No. of hosts who are excluded";
      }

      list host {
        description "List of hosts";
        uses IGMP-EDM-GROUPS-HOST-BAG;
      }  // list host
    }  // grouping IGMP-EDM-GROUPS-ET-BAG

    grouping IGMP-EDM-SSM-MAP-BAG {
      description "IGMP SSM Map List";
      container group-address-xr {
        description "Group Address";
        uses IGMP-ADDRTYPE;
      }  // container group-address-xr

      leaf map-type {
        type uint32;
        description "Map Type of group";
      }

      leaf source-counts {
        type uint32;
        description "Count of Sources";
      }
    }  // grouping IGMP-EDM-SSM-MAP-BAG

    grouping IGMP-EDM-NOT-ACTIVE-GROUP-BAG {
      description "IGMP Non active group";
      container group-address {
        description "Group Address";
        uses IGMP-ADDRTYPE;
      }  // container group-address

      container source-address {
        description "Source Address";
        uses IGMP-ADDRTYPE;
      }  // container source-address

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

      leaf reason-for-non-activity {
        type string {
          length "0..257";
        }
        description
          "Reason for group join not being processed";
      }
    }  // grouping IGMP-EDM-NOT-ACTIVE-GROUP-BAG

    grouping IGMP-EDM-NOT-ACTIVE-ALLGROUPS-BAG {
      description
        "IGMP Non active groups list";
      list non-active-groups {
        description
          "List of non-active groups";
        uses IGMP-EDM-NOT-ACTIVE-GROUP-BAG;
      }  // list non-active-groups
    }  // grouping IGMP-EDM-NOT-ACTIVE-ALLGROUPS-BAG

    grouping IGMP-EDM-GROUPS-SOURCE-BAG {
      description "IGMP Groups source entry";
      container source-address {
        description "Source Address";
        uses IGMP-ADDRTYPE;
      }  // container source-address

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expiration-time {
        type int32;
        units "second";
        description
          "Expiration time in seconds";
      }

      leaf is-local {
        type boolean;
        description "Is this a local source";
      }

      leaf is-remote {
        type boolean;
        description
          "Is this a remote source";
      }

      leaf is-forward {
        type boolean;
        description
          "Should we forward on this entry";
      }

      leaf is-we-report {
        type boolean;
        description
          "Should we report the source";
      }

      leaf flags {
        type int32;
        description "Source flags";
      }

      leaf is-added {
        type boolean;
        description "Joined";
      }

      leaf is-evpn-remote {
        type boolean;
        description
          "Route learnt through EVPN";
      }
    }  // grouping IGMP-EDM-GROUPS-SOURCE-BAG

    grouping IGMP-EDM-GROUPS-BAG {
      description "IGMP group entry";
      container group-address-xr {
        description "Group Address";
        uses IGMP-ADDRTYPE;
      }  // container group-address-xr

      container last-reporter {
        description "Last reporter address";
        uses IGMP-ADDRTYPE;
      }  // container last-reporter

      container source-address {
        description "Source Address";
        uses IGMP-ADDRTYPE;
      }  // container source-address

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

      leaf uptime {
        type uint64;
        units "second";
        description "Uptime in seconds";
      }

      leaf expiration-time {
        type int32;
        units "second";
        description
          "Expiration time in seconds";
      }

      leaf explicit-tracking-enabled {
        type boolean;
        description
          "Is explicit tracking enabled";
      }

      leaf is-self-join {
        type boolean;
        description
          "If local system is member of this group on this
         interface";
      }

      leaf row-status {
        type string {
          length "0..16";
        }
        description
          "interface on or off for the group";
      }

      leaf is-low-memory {
        type boolean;
        description
          "Node is running low on memory";
      }

      leaf router-filter-mode {
        type uint8;
        description "Filter mode";
      }

      leaf older-host-version1-timer {
        type uint32;
        description "IGMP Hostversion1timer";
      }

      leaf older-host-version2-timer {
        type uint32;
        description "IGMP Hostversion2timer";
      }

      leaf is-added {
        type boolean;
        description "Joined";
      }

      leaf is-suppressed {
        type boolean;
        description "Suppressed";
      }

      leaf is-evpn-remote {
        type boolean;
        description "EVPN remote flag";
      }

      leaf is-evpn-stale {
        type boolean;
        description "EVPN stale flag";
      }
    }  // grouping IGMP-EDM-GROUPS-BAG

    grouping IGMP-EDM-GROUPS-DETAIL-BAG {
      description "IGMP group detail entry";
      container group-info {
        description
          "Basic Group information";
        uses IGMP-EDM-GROUPS-BAG;
      }  // container group-info

      leaf is-router-exclude-mode {
        type boolean;
        description
          "Group router filter mode";
      }

      leaf is-host-exclude-mode {
        type boolean;
        description "Group host filter mode";
      }

      list source {
        description "List of sources";
        uses IGMP-EDM-GROUPS-SOURCE-BAG;
      }  // list source
    }  // grouping IGMP-EDM-GROUPS-DETAIL-BAG

    grouping IGMP-ADDRTYPE {
      description "IGMP ADDRTYPE";
      leaf af-name {
        type Igmp-afi;
        description "AFName";
      }

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

      leaf ipv6-address {
        when "../af-name = 'ipv6-unicast'" {
          description
            "../AFName = 'IPv6Unicast'";
        }
        type Ipv6-address;
        description "IPV6 Addr";
      }
    }  // grouping IGMP-ADDRTYPE

    grouping IGMP-EDM-IDB-BAG {
      description "IGMP interface entry";
      container address {
        description "IP address";
        uses IGMP-ADDRTYPE;
      }  // container address

      container querier-address {
        description "Address of the Querier";
        uses IGMP-ADDRTYPE;
      }  // container querier-address

      container subscriber-address {
        description "Address of subscriber";
        uses IGMP-ADDRTYPE;
      }  // container subscriber-address

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

      leaf state {
        type Im-state;
        description "Interface state";
      }

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

      leaf is-interface-up {
        type boolean;
        description "Is interface up";
      }

      leaf is-ip-enabled {
        type boolean;
        description "Is IP enabled";
      }

      leaf is-router-enabled {
        type boolean;
        description
          "Is Router functionality enabled";
      }

      leaf is-multi-homing-enabled {
        type boolean;
        description "Is Multihoming enabled";
      }

      leaf is-multi-homing-stale {
        type boolean;
        description
          "Is Multihoming Update stale";
      }

      leaf igmp-version {
        type uint8;
        description "IGMP Router version";
      }

      leaf host-version {
        type uint8;
        description "IGMP Host version";
      }

      leaf query-interval {
        type uint16;
        units "second";
        description
          "Query Interval value in seconds";
      }

      leaf query-timeout {
        type uint16;
        description "Query Timeout value";
      }

      leaf query-maximum-response-time {
        type uint16;
        description
          "Max Response Timeout value";
      }

      leaf last-member-query-interval {
        type uint16;
        description
          "Last Member Query Interval";
      }

      leaf group-joins {
        type uint32;
        description "No. of group joins";
      }

      leaf group-leaves {
        type uint32;
        description "No. of group leaves";
      }

      leaf is-querier {
        type boolean;
        description "Are we querier";
      }

      leaf total-active-groups {
        type uint32;
        description
          "Actual number of groups on interface";
      }

      leaf robustness {
        type uint32;
        description
          "Robustness Variable value";
      }

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

      leaf querier-uptime {
        type uint16;
        description
          "Time since the last querier took over";
      }

      leaf las-ll-registration-count {
        type uint32;
        description "LAS reg count";
      }

      leaf las-get-address-count {
        type uint32;
        description "LAS get addr count";
      }

      leaf las-update-count {
        type uint32;
        description "LAS Update count";
      }

      leaf las-ll-remove-update-count {
        type uint32;
        description
          "LAS LL remove update count";
      }

      leaf las-ll-add-update-count {
        type uint32;
        description
          "LAS LL add update count";
      }

      leaf las-null-update-count {
        type uint32;
        description "LAS Null update count";
      }

      leaf las-unregistration-count {
        type uint32;
        description "LAS unreg count";
      }

      leaf is-las-request {
        type boolean;
        description "LAS req";
      }

      leaf is-las-registered {
        type boolean;
        description "LAS registered";
      }

      leaf vrf-id {
        type uint32;
        description "VRF id";
      }

      leaf mte-vrf-id {
        type uint32;
        description "MTE VRF id";
      }

      leaf location {
        type uint32;
        description "Location";
      }

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

      leaf vrf-state {
        type uint32;
        description "Vrf State";
      }

      leaf is-configurationverify {
        type boolean;
        description "CFG verify";
      }

      leaf configurationvrf-set {
        type boolean;
        description "CFG vrf set";
      }

      leaf configurationvrf-error {
        type boolean;
        description "CFG vrf error";
      }

      leaf configuration-mcast-vrf-set {
        type boolean;
        description "Is mcast set";
      }

      leaf configuration-mcast-vrf-error {
        type boolean;
        description "Is mcast error";
      }

      leaf is-im-state-registered {
        type boolean;
        description "Im state registered";
      }

      leaf is-subscriber {
        type boolean;
        description "Subscriber interface";
      }

      leaf subscriber-mode {
        type uint32;
        description "Subscriber mode";
      }

      leaf is-identity-present {
        type boolean;
        description
          "Subscriber ID or Address available from AAA";
      }

      leaf subscriber-id {
        type string {
          length "0..257";
        }
        description
          "ID string of subscriber";
      }

      leaf parent-ifhandle {
        type xr:Interface-name;
        description "Parent If Handle";
      }

      leaf time-since-last-query-in-seconds {
        type uint32;
        description
          "Time elapsed since last query";
      }

      leaf time-since-last-report-in-seconds {
        type uint32;
        description
          "Time elapsed since last report";
      }

      leaf router-uptime-in-seconds {
        type uint32;
        description
          "Uptime since router enabled event";
      }

      leaf mte-tuple-count {
        type uint32;
        description "MTE Tuple count";
      }
    }  // grouping IGMP-EDM-IDB-BAG

    grouping IGMP-EDM-INTF-SUMMARY-BAG {
      description
        "IGMP interface summary info";
      leaf interface-name {
        type xr:Interface-name;
        description "Interface";
      }

      leaf group-limit {
        type uint32;
        description
          "Maximum groups accepted per interface";
      }

      leaf group-count {
        type uint32;
        description
          "Current groups accepted per interface";
      }

      leaf parent-ifhandle {
        type xr:Interface-name;
        description "Parent if handle";
      }

      leaf on-off {
        type boolean;
        description "Enabled/Disabled";
      }

      leaf time-since-last-query-in-seconds {
        type uint32;
        description
          "Time elapsed since last query";
      }

      leaf time-since-last-report-in-seconds {
        type uint32;
        description
          "Time elapsed since last report";
      }

      leaf router-uptime-in-seconds {
        type uint32;
        description
          "Time elapsed since router enabled event";
      }
    }  // grouping IGMP-EDM-INTF-SUMMARY-BAG

    grouping IGMP-EDM-SUMMARY-BAG {
      description "IGMP summary info";
      leaf robustness {
        type uint32;
        description "Robustness variable";
      }

      leaf group-limit {
        type uint32;
        description
          "Maximum groups accepted";
      }

      leaf group-count {
        type uint32;
        description
          "Current groups accepted";
      }

      leaf is-disabled {
        type boolean;
        description
          "Is maximum enforcement disabled";
      }

      leaf is-evpn-connection-up {
        type boolean;
        description "Is EVPN connection up";
      }

      leaf supported-interfaces {
        type uint32;
        description
          "No. of supported interfaces";
      }

      leaf unsupported-interfaces {
        type uint32;
        description
          "No. of unsupported interfaces";
      }

      leaf enabled-interface-count {
        type uint32;
        description
          "No. of enabled interfaces";
      }

      leaf disabled-interface-count {
        type uint32;
        description
          "No. of disabled interfaces";
      }

      leaf multi-homing-enabled-interfaces {
        type uint32;
        description
          "No. of EVPN MH enabled interfaces";
      }

      leaf tunnel-mte-config-count {
        type uint32;
        description
          "No. of static group commands";
      }

      leaf node-low-memory {
        type boolean;
        description
          "Is node in low memory condition";
      }

      leaf querier-number {
        type uint32;
        description
          "Number of querier interfaces";
      }

      list interface {
        description
          "Maximum and current groups accepted for each
         interface";
        uses IGMP-EDM-INTF-SUMMARY-BAG;
      }  // list interface
    }  // grouping IGMP-EDM-SUMMARY-BAG
  }  // submodule Cisco-IOS-XR-mld-oper-sub1