/*
 * Copyright (c) 2017 Juniper Networks, Inc.
 * All rights reserved.
 */

 module show-mld {
  namespace "http://yang.juniper.net/yang/1.1/jrpc";
  prefix jrpc;

  import junos-extension {
    prefix junos;
  }

  organization
    "Juniper Networks, Inc.";

  description
    "Junos YANG module for RPC";

   typedef daemon {
     type string;
   }
   typedef filename {
     type string;
   }
   typedef client-filename {
     type string;
   }
   typedef hostname {
     type string;
   }
   typedef ipaddr {
     type string;
   }
   typedef sysid {
     type string;
   }
   typedef interface-device {
     type string;
   }
   typedef ddl-bits {
     type string;
   }
   typedef isoaddr {
     type string;
   }
   typedef ipprefix {
     type string;
   }
   typedef ipprefix-mandatory {
     type string;
   }
   typedef interface-unit {
     type string;
   }
   typedef ipaddr-or-interface {
     type string;
   }
   typedef areaid {
     type string;
   }
   typedef interface-name {
     type string;
   }
   typedef community {
     type string;
   }
   typedef interface-wildcard {
     type string;
   }
   typedef unreadable {
     type string;
   }
   typedef ipprefix-optional {
     type string;
   }
   typedef policy-algebra {
     type string;
   }
   typedef regular-expression {
     type string;
   }
   typedef group-glob {
     type string;
   }
   typedef atm-vci {
     type string;
   }
   typedef ipprefix-only {
     type string;
   }
   typedef ipv4addr {
     type string;
   }
   typedef ipv4prefix {
     type string;
   }
   typedef ipv4prefix-mandatory {
     type string;
   }
   typedef ipv4addr-or-interface {
     type string;
   }
   typedef ipv4prefix-optional {
     type string;
   }
   typedef ipv4prefix-only {
     type string;
   }
   typedef ipv6addr {
     type string;
   }
   typedef ipv6prefix {
     type string;
   }
   typedef ipv6prefix-mandatory {
     type string;
   }
   typedef ipv6addr-or-interface {
     type string;
   }
   typedef ipv6prefix-optional {
     type string;
   }
   typedef ipv6prefix-only {
     type string;
   }
   typedef interface-device-wildcard {
     type string;
   }
   typedef time {
     type string;
   }
   typedef mac-addr {
     type string;
   }
   typedef mac-addr-prefix {
     type string;
   }
   typedef mac-unicaset {
     type string;
   }
   typedef mac-unicast-prefix {
     type string;
   }
   typedef mac-multicast {
     type string;
   }
   typedef mac-multicast-prefix {
     type string;
   }
   typedef mpls-label {
     type string;
   }
   typedef unsigned-float {
     type string;
   }
   typedef isoprefix {
     type string;
   }
   typedef isosysid {
     type string;
   }
   typedef string-huge {
     type string;
   }
   typedef variable {
     type string;
   }
   typedef glob-variable {
     type string;
   }
   typedef vlan-range {
     type string;
   }
   typedef interface-range-wild {
     type string;
   }
   typedef fc-addr {
     type string;
   }
   typedef wwn {
     type string;
   }
   typedef logfilename {
     type string;
   }
   typedef range {
     type string;
   }
   typedef esi {
     type string;
   }

   rpc get-mld-group-information {
     description "Show MLD group members";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "brief";
         type enumeration {
           enum "terse" {
             description "Display terse output";
           }
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf group-name {
         description "Name of group";
         type string;
       }
     }
     output {
       container mld-group-information {
         container mgm-interface-groups {
           leaf interface-name {
             type string;
             description "Name of interface";
           }
           leaf mgm-group-count {
             type int32;
           }
           container mgm-group {
             container igmp-terse {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               container host-record {
                 leaf record-type {
                   type string;
                 }
                 leaf receiver {
                   type ipaddr;
                 }
                 leaf record-timeout {
                   type int32;
                 }
               }
               container reverse-oif {
                 leaf oif-name {
                   type string;
                   description "Reverse OIF name";
                 }
                 leaf host-count {
                   type int32;
                   description "Host reference count";
                 }
               }
             }
             container igmp {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf last-address {
                 type ipaddr;
               }
               leaf mgm-timeout {
                 type int32;
               }
               leaf mgm-type {
                 type string;
               }
               container host-record {
                 leaf record-type {
                   type string;
                 }
                 leaf receiver {
                   type ipaddr;
                 }
                 leaf record-timeout {
                   type int32;
                 }
               }
               container reverse-oif {
                 leaf oif-name {
                   type string;
                   description "Reverse OIF name";
                 }
                 leaf host-count {
                   type int32;
                   description "Host reference count";
                 }
               }
             }
             container igmp-detail {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf mgm-source-timeout {
                 type int32;
                 description "Amount of time for which the traffic from source is forwarded.";
               }
               leaf last-address {
                 type ipaddr;
               }
               leaf mgm-timeout {
                 type int32;
               }
               leaf mgm-type {
                 type string;
               }
               leaf mgm-type-instance {
                 type string;
               }
               leaf mgm-group-output-interface {
                 type string;
                 description "Group output interface";
               }
               leaf mgm-output-interface-status {
                 type string;
                 description "Group output interface status";
               }
               container host-record {
                 leaf record-type {
                   type string;
                 }
                 leaf receiver {
                   type ipaddr;
                 }
                 leaf record-timeout {
                   type int32;
                 }
               }
               container reverse-oif {
                 leaf oif-name {
                   type string;
                   description "Reverse OIF name";
                 }
                 leaf host-count {
                   type int32;
                   description "Host reference count";
                 }
               }
             }
             container mld-terse {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               container host-record {
                 leaf record-type {
                   type string;
                 }
                 leaf receiver {
                   type ipaddr;
                 }
                 leaf record-timeout {
                   type int32;
                 }
               }
               container reverse-oif {
                 leaf oif-name {
                   type string;
                   description "Reverse OIF name";
                 }
                 leaf host-count {
                   type int32;
                   description "Host reference count";
                 }
               }
             }
             container mld {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf last-address {
                 type ipaddr;
               }
               leaf mgm-timeout {
                 type int32;
               }
               leaf mgm-type {
                 type string;
               }
               container host-record {
                 leaf record-type {
                   type string;
                 }
                 leaf receiver {
                   type ipaddr;
                 }
                 leaf record-timeout {
                   type int32;
                 }
               }
               container reverse-oif {
                 leaf oif-name {
                   type string;
                   description "Reverse OIF name";
                 }
                 leaf host-count {
                   type int32;
                   description "Host reference count";
                 }
               }
             }
             container mld-detail {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf mgm-source-timeout {
                 type int32;
                 description "Amount of time for which the traffic from source is forwarded.";
               }
               leaf last-address {
                 type ipaddr;
               }
               leaf mgm-timeout {
                 type int32;
               }
               leaf mgm-type {
                 type string;
               }
               leaf mgm-group-output-interface {
                 type string;
                 description "Group output interface";
               }
               leaf mgm-output-interface-status {
                 type string;
                 description "Group output interface status";
               }
               container host-record {
                 leaf record-type {
                   type string;
                 }
                 leaf receiver {
                   type ipaddr;
                 }
                 leaf record-timeout {
                   type int32;
                 }
               }
               container reverse-oif {
                 leaf oif-name {
                   type string;
                   description "Reverse OIF name";
                 }
                 leaf host-count {
                   type int32;
                   description "Host reference count";
                 }
               }
             }
           }
         }
       }
     }
   }
   rpc get-mld-output-group-information {
     description "Show MLD output group members";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "brief";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf group-name {
         description "Name of group";
         type string;
       }
     }
     output {
       container mld-output-group-information {
         container mgm-interface-output-groups {
           leaf interface-name {
             type string;
             description "Name of interface";
           }
           leaf mgm-output-interface-status {
             type string;
             description "Group output interface status";
           }
           container mgm-output-group {
             container igmp {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf mgm-type {
                 type string;
               }
             }
             container igmp-detail {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf mgm-group-input-interface {
                 type string;
                 description "Group input interface";
               }
               leaf mgm-type {
                 type string;
               }
             }
             container mld {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf mgm-type {
                 type string;
               }
             }
             container mld-detail {
               leaf multicast-group-address {
                 type ipaddr;
                 description "Group address";
               }
               leaf mgm-group-mode-type {
                 type string;
                 description "Group operational mode (Include/Exclude).";
               }
               leaf multicast-source-address {
                 type ipaddr;
                 description "Source address";
               }
               leaf mgm-group-input-interface {
                 type string;
                 description "Group input interface";
               }
               leaf mgm-type {
                 type string;
               }
             }
           }
         }
       }
     }
   }
   rpc get-mld-interface-information {
     description "Show MLD interfaces";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "brief";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf interface-name {
         description "Name of interface";
         type string;
       }
     }
     output {
       container mld-interface-information {
         container mgm-interface {
           leaf interface-name {
             type string;
             description "Name of interface";
           }
           leaf querier-address {
             type ipaddr;
           }
           leaf mgm-interface-state {
             type string;
           }
           leaf querier-timeout {
             type int32;
           }
           leaf mgm-interface-version {
             type int32;
           }
           leaf mgm-group-count {
             type int32;
           }
           leaf mgm-group-limit {
             type uint32;
             description "Maximum number of (source,group) per interface";
           }
           leaf mgm-group-threshold {
             type uint32;
             description "Percentage of maximum at which to start generating warnings";
           }
           leaf mgm-group-log-interval {
             type uint32;
             description "Percentage of maximum at which to start generating warnings";
           }
           leaf mgm-ssm-map {
             type string;
             description "Name of source-specific multicast map";
           }
           leaf mgm-ssm-map-policy {
             type string;
             description "Name of source-specific multicast map policy";
           }
           leaf mgm-immediate-leave {
             type string;
             description "Groups are removed immediately without sending last membership queries";
           }
           leaf mgm-promiscuous-mode {
             type string;
             description "IGMP messages coming from different subnet are accepted";
           }
           leaf mgm-passive {
             type string;
             description "Do not send or receive control messages";
           }
           leaf mgm-passive-allow-receive {
             type empty;
             description "Allow receiving control messages";
           }
           leaf mgm-passive-send-general-query {
             type empty;
             description "Send general query messages";
           }
           leaf mgm-passive-send-group-query {
             type empty;
             description "Send group query messages";
           }
           leaf mgm-group-policy {
             type string;
             description "Group filter applied to incoming Report messages";
           }
           leaf mgm-oif-map {
             type string;
             description "Output interface mapping policy";
           }
           leaf remote-pe-address {
             type ipaddr;
           }
           leaf mgm-mc-lag-state {
             type string;
             description "State of the mc-lag interface";
           }
           container mgm-host {
             container igmp {
               leaf mgm-host-address {
                 type ipaddr;
               }
               leaf mgm-host-record-count {
                 type int32;
               }
             }
             container mld {
               leaf mgm-host-address {
                 type ipaddr;
               }
               leaf mgm-host-record-count {
                 type int32;
               }
             }
           }
         }
         container mgm-configured-parameters {
           leaf query-interval {
             type string;
           }
           leaf query-response-interval {
             type string;
           }
           leaf last-member-query-interval {
             type string;
           }
           leaf robustness-count {
             type int32;
           }
           leaf igmp-l2-querier {
             type string;
             description "IGMP L2 querier";
           }
           leaf l2-querier-source-address {
             type ipaddr;
           }
           container igmp {
           }
           container mld {
             leaf query-interval {
               type string;
             }
             leaf query-response-interval {
               type string;
             }
             leaf last-member-query-interval {
               type string;
             }
             leaf robustness-count {
               type int32;
             }
           }
         }
         container mgm-derived-parameters {
           leaf membership-timeout {
             type string;
           }
           leaf query-other-timeout {
             type string;
           }
           container igmp {
           }
           container mld {
             leaf membership-timeout {
               type string;
             }
             leaf query-other-timeout {
               type string;
             }
           }
         }
       }
     }
   }
   rpc get-mld-statistics-information {
     description "Show MLD statistics";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
     }
     output {
       container mld-statistics-information {
         container mgm-statistics-interface {
           container igmp {
             leaf interface-name {
               type string;
               description "Name of interface";
             }
             leaf mgm-disabled-interface-name {
               type string;
             }
             leaf mgm-interface-all {
               type empty;
             }
             container mgm-statistics-group {
               container mgm-statistic {
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-other {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-global {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
           container mld {
             leaf interface-name {
               type string;
               description "Name of interface";
             }
             leaf mgm-disabled-interface-name {
               type string;
             }
             leaf mgm-interface-all {
               type empty;
             }
             container mgm-statistics-group {
               container mgm-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-other {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-global {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
         }
         container mgm-statistics-other {
           container mgm-other-statistic {
             container igmp {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container igmp-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
           }
         }
         container mgm-statistics-global {
           container mgm-other-statistic {
             container igmp {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container igmp-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
           }
         }
         container mgm-statistics-all {
           container mgm-statistics-group {
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
           }
           container mgm-statistics-other {
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
           container mgm-statistics-global {
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
         }
       }
     }
   }
   rpc get-mld-snooping-options-information {
     description "Show MLD snooping options";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "detail";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf instance {
         description "Name of routing-instance";
         type string;
       }
     }
   }
   rpc get-mld-snooping-membership-information {
     description "Show MLD snooping group membership";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "detail";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf group {
         description "IP address range for group";
         type ipv6prefix;
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
       leaf vlan-id {
         description "VLAN ID for a learning domain";
         type uint32 {
           range "0 .. 4094";
         }
       }
       leaf instance {
         description "Name of routing-instance";
         type string;
       }
     }
   }
   rpc get-mld-snooping-bridge-domain-membership {
     description "For a particular bridge-domain";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "detail";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf virtual-switch {
         description "Name of virtual-switch instance";
         type string;
       }
       leaf domain-name {
         description "Name of bridge-domain";
         type string;
         mandatory true;
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
       leaf vlan-id {
         description "VLAN ID for a learning domain";
         type uint32 {
           range "0 .. 4094";
         }
       }
       leaf group {
         description "IP address range for group";
         type ipv6prefix;
       }
     }
   }
   rpc get-mld-snooping-interface-information {
     description "Show MLD snooping interfaces";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "detail";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
       leaf vlan-id {
         description "VLAN ID for a learning domain";
         type uint32 {
           range "0 .. 4094";
         }
       }
       leaf instance {
         description "Name of routing-instance";
         type string;
       }
     }
     output {
       container mld-interface-information {
         container mgm-interface {
           leaf interface-name {
             type string;
             description "Name of interface";
           }
           leaf querier-address {
             type ipaddr;
           }
           leaf mgm-interface-state {
             type string;
           }
           leaf querier-timeout {
             type int32;
           }
           leaf mgm-interface-version {
             type int32;
           }
           leaf mgm-group-count {
             type int32;
           }
           leaf mgm-group-limit {
             type uint32;
             description "Maximum number of (source,group) per interface";
           }
           leaf mgm-group-threshold {
             type uint32;
             description "Percentage of maximum at which to start generating warnings";
           }
           leaf mgm-group-log-interval {
             type uint32;
             description "Percentage of maximum at which to start generating warnings";
           }
           leaf mgm-ssm-map {
             type string;
             description "Name of source-specific multicast map";
           }
           leaf mgm-ssm-map-policy {
             type string;
             description "Name of source-specific multicast map policy";
           }
           leaf mgm-immediate-leave {
             type string;
             description "Groups are removed immediately without sending last membership queries";
           }
           leaf mgm-promiscuous-mode {
             type string;
             description "IGMP messages coming from different subnet are accepted";
           }
           leaf mgm-passive {
             type string;
             description "Do not send or receive control messages";
           }
           leaf mgm-passive-allow-receive {
             type empty;
             description "Allow receiving control messages";
           }
           leaf mgm-passive-send-general-query {
             type empty;
             description "Send general query messages";
           }
           leaf mgm-passive-send-group-query {
             type empty;
             description "Send group query messages";
           }
           leaf mgm-group-policy {
             type string;
             description "Group filter applied to incoming Report messages";
           }
           leaf mgm-oif-map {
             type string;
             description "Output interface mapping policy";
           }
           leaf remote-pe-address {
             type ipaddr;
           }
           leaf mgm-mc-lag-state {
             type string;
             description "State of the mc-lag interface";
           }
           container mgm-host {
             container igmp {
               leaf mgm-host-address {
                 type ipaddr;
               }
               leaf mgm-host-record-count {
                 type int32;
               }
             }
             container mld {
               leaf mgm-host-address {
                 type ipaddr;
               }
               leaf mgm-host-record-count {
                 type int32;
               }
             }
           }
         }
         container mgm-configured-parameters {
           leaf query-interval {
             type string;
           }
           leaf query-response-interval {
             type string;
           }
           leaf last-member-query-interval {
             type string;
           }
           leaf robustness-count {
             type int32;
           }
           leaf igmp-l2-querier {
             type string;
             description "IGMP L2 querier";
           }
           leaf l2-querier-source-address {
             type ipaddr;
           }
           container igmp {
           }
           container mld {
             leaf query-interval {
               type string;
             }
             leaf query-response-interval {
               type string;
             }
             leaf last-member-query-interval {
               type string;
             }
             leaf robustness-count {
               type int32;
             }
           }
         }
         container mgm-derived-parameters {
           leaf membership-timeout {
             type string;
           }
           leaf query-other-timeout {
             type string;
           }
           container igmp {
           }
           container mld {
             leaf membership-timeout {
               type string;
             }
             leaf query-other-timeout {
               type string;
             }
           }
         }
       }
     }
   }
   rpc get-mld-snooping-bridge-domain-interface {
     description "For a particular bridge-domain";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "detail";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf virtual-switch {
         description "Name of virtual-switch instance";
         type string;
       }
       leaf domain-name {
         description "Name of bridge-domain";
         type string;
         mandatory true;
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
       leaf vlan-id {
         description "VLAN ID for a learning domain";
         type uint32 {
           range "0 .. 4094";
         }
       }
     }
     output {
       container mld-interface-information {
         container mgm-interface {
           leaf interface-name {
             type string;
             description "Name of interface";
           }
           leaf querier-address {
             type ipaddr;
           }
           leaf mgm-interface-state {
             type string;
           }
           leaf querier-timeout {
             type int32;
           }
           leaf mgm-interface-version {
             type int32;
           }
           leaf mgm-group-count {
             type int32;
           }
           leaf mgm-group-limit {
             type uint32;
             description "Maximum number of (source,group) per interface";
           }
           leaf mgm-group-threshold {
             type uint32;
             description "Percentage of maximum at which to start generating warnings";
           }
           leaf mgm-group-log-interval {
             type uint32;
             description "Percentage of maximum at which to start generating warnings";
           }
           leaf mgm-ssm-map {
             type string;
             description "Name of source-specific multicast map";
           }
           leaf mgm-ssm-map-policy {
             type string;
             description "Name of source-specific multicast map policy";
           }
           leaf mgm-immediate-leave {
             type string;
             description "Groups are removed immediately without sending last membership queries";
           }
           leaf mgm-promiscuous-mode {
             type string;
             description "IGMP messages coming from different subnet are accepted";
           }
           leaf mgm-passive {
             type string;
             description "Do not send or receive control messages";
           }
           leaf mgm-passive-allow-receive {
             type empty;
             description "Allow receiving control messages";
           }
           leaf mgm-passive-send-general-query {
             type empty;
             description "Send general query messages";
           }
           leaf mgm-passive-send-group-query {
             type empty;
             description "Send group query messages";
           }
           leaf mgm-group-policy {
             type string;
             description "Group filter applied to incoming Report messages";
           }
           leaf mgm-oif-map {
             type string;
             description "Output interface mapping policy";
           }
           leaf remote-pe-address {
             type ipaddr;
           }
           leaf mgm-mc-lag-state {
             type string;
             description "State of the mc-lag interface";
           }
           container mgm-host {
             container igmp {
               leaf mgm-host-address {
                 type ipaddr;
               }
               leaf mgm-host-record-count {
                 type int32;
               }
             }
             container mld {
               leaf mgm-host-address {
                 type ipaddr;
               }
               leaf mgm-host-record-count {
                 type int32;
               }
             }
           }
         }
         container mgm-configured-parameters {
           leaf query-interval {
             type string;
           }
           leaf query-response-interval {
             type string;
           }
           leaf last-member-query-interval {
             type string;
           }
           leaf robustness-count {
             type int32;
           }
           leaf igmp-l2-querier {
             type string;
             description "IGMP L2 querier";
           }
           leaf l2-querier-source-address {
             type ipaddr;
           }
           container igmp {
           }
           container mld {
             leaf query-interval {
               type string;
             }
             leaf query-response-interval {
               type string;
             }
             leaf last-member-query-interval {
               type string;
             }
             leaf robustness-count {
               type int32;
             }
           }
         }
         container mgm-derived-parameters {
           leaf membership-timeout {
             type string;
           }
           leaf query-other-timeout {
             type string;
           }
           container igmp {
           }
           container mld {
             leaf membership-timeout {
               type string;
             }
             leaf query-other-timeout {
               type string;
             }
           }
         }
       }
     }
   }
   rpc get-mld-snooping-statistics-information {
     description "Show MLD snooping statistics";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
       leaf vlan-id {
         description "VLAN ID for a learning domain";
         type uint32 {
           range "0 .. 4094";
         }
       }
       leaf instance {
         description "Name of routing-instance";
         type string;
       }
     }
     output {
       container mld-statistics-information {
         container mgm-statistics-interface {
           container igmp {
             leaf interface-name {
               type string;
               description "Name of interface";
             }
             leaf mgm-disabled-interface-name {
               type string;
             }
             leaf mgm-interface-all {
               type empty;
             }
             container mgm-statistics-group {
               container mgm-statistic {
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-other {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-global {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
           container mld {
             leaf interface-name {
               type string;
               description "Name of interface";
             }
             leaf mgm-disabled-interface-name {
               type string;
             }
             leaf mgm-interface-all {
               type empty;
             }
             container mgm-statistics-group {
               container mgm-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-other {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-global {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
         }
         container mgm-statistics-other {
           container mgm-other-statistic {
             container igmp {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container igmp-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
           }
         }
         container mgm-statistics-global {
           container mgm-other-statistic {
             container igmp {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container igmp-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
           }
         }
         container mgm-statistics-all {
           container mgm-statistics-group {
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
           }
           container mgm-statistics-other {
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
           container mgm-statistics-global {
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
         }
       }
     }
   }
   rpc get-mld-snooping-bridge-domain-statistics {
     description "For a particular bridge-domain";
     input {
       leaf logical-system {
         description "Name of logical system, or 'all'";
         type string {
           junos:posix-pattern "^[a-zA-Z0-9_-]{1,63}$";
           junos:pattern-message "Logical-system name is a string consisting of up to 63 letters, numbers, dashes and underscores";
         }
       }
       leaf verbosity_level {
         default "detail";
         type enumeration {
           enum "brief" {
             description "Display brief output (default)";
           }
           enum "detail" {
             description "Display detailed output";
           }
         }
       }
       leaf virtual-switch {
         description "Name of virtual-switch instance";
         type string;
       }
       leaf domain-name {
         description "Name of bridge-domain";
         type string;
         mandatory true;
       }
       leaf interface {
         description "Name of interface";
         type string;
       }
       leaf vlan-id {
         description "VLAN ID for a learning domain";
         type uint32 {
           range "0 .. 4094";
         }
       }
     }
     output {
       container mld-statistics-information {
         container mgm-statistics-interface {
           container igmp {
             leaf interface-name {
               type string;
               description "Name of interface";
             }
             leaf mgm-disabled-interface-name {
               type string;
             }
             leaf mgm-interface-all {
               type empty;
             }
             container mgm-statistics-group {
               container mgm-statistic {
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-other {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-global {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
           container mld {
             leaf interface-name {
               type string;
               description "Name of interface";
             }
             leaf mgm-disabled-interface-name {
               type string;
             }
             leaf mgm-interface-all {
               type empty;
             }
             container mgm-statistics-group {
               container mgm-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf received-count {
                     type int32;
                   }
                   leaf sent-count {
                     type int32;
                   }
                   leaf error-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-other {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistics-global {
               container mgm-other-statistic {
                 container igmp {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container igmp-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
                 container mld-global-hack {
                   leaf statistic-name {
                     type string;
                   }
                   leaf statistic-count {
                     type int32;
                   }
                 }
               }
             }
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
         }
         container mgm-statistics-other {
           container mgm-other-statistic {
             container igmp {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container igmp-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
           }
         }
         container mgm-statistics-global {
           container mgm-other-statistic {
             container igmp {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container igmp-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
             container mld-global-hack {
               leaf statistic-name {
                 type string;
               }
               leaf statistic-count {
                 type int32;
               }
             }
           }
         }
         container mgm-statistics-all {
           container mgm-statistics-group {
             container mgm-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf received-count {
                   type int32;
                 }
                 leaf sent-count {
                   type int32;
                 }
                 leaf error-count {
                   type int32;
                 }
               }
             }
           }
           container mgm-statistics-other {
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
           container mgm-statistics-global {
             container mgm-other-statistic {
               container igmp {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container igmp-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
               container mld-global-hack {
                 leaf statistic-name {
                   type string;
                 }
                 leaf statistic-count {
                   type int32;
                 }
               }
             }
           }
         }
       }
     }
   }
 }
