Cisco-IOS-XR-l2vpn-cfg

This module contains a collection of YANG definitions for Cisco IOS-XR l2vpn package configuration. This module contains defini...

  • Version: 2021-06-09

    Cisco-IOS-XR-l2vpn-cfg@2021-06-09


    
      module Cisco-IOS-XR-l2vpn-cfg {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-l2vpn-cfg";
    
        prefix l2vpn-cfg;
    
        import ietf-inet-types {
          prefix inet;
        }
        import ietf-yang-types {
          prefix yang;
        }
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
        import Cisco-IOS-XR-ifmgr-cfg {
          prefix a1;
        }
        import Cisco-IOS-XR-snmp-agent-cfg {
          prefix a2;
        }
    
        organization "Cisco Systems, Inc.";
    
        contact
          "Cisco Systems, Inc.
    Customer Service
    
    Postal: 170 West Tasman Drive
    San Jose, CA 95134
    
    Tel: +1 800 553-NETS
    
    E-mail: cs-yang@cisco.com";
    
        description
          "This module contains a collection of YANG definitions
    for Cisco IOS-XR l2vpn package configuration.
    
    This module contains definitions
    for the following management objects:
      l2vpn: L2VPN configuration
      generic-interface-lists: Generic Interface List configuration
      evpn: EVPN configuration
    
    This YANG module augments the
      Cisco-IOS-XR-ifmgr-cfg,
      Cisco-IOS-XR-snmp-agent-cfg
    modules with configuration data.
    
    Copyright (c) 2013-2021 by Cisco Systems, Inc.
    All rights reserved.";
    
        revision "2021-06-09" {
          description
            "- Added support for enforce-mtu-match CLI globally under evpn submode - Added support for transmit-l2-mtu CLI globally under evpn submode - Added support for enforce-mtu-match CLI under evpn instance submode - Added support for transmit-l2-mtu CLI under evpn instance submode
    2020-08-08
      Added support for ignore-mtu-mismatch and transmit-mtu-zero CLI globally under evpn submode.";
        }
    
        revision "2020-06-29" {
          description
            "Changed key for Pseudowire type to IPv4 neighbor - PW-ID or IPv6 neighbor - PW-id pair.
    2019-12-20
    EVPN SRv6 related changes";
        }
    
        revision "2019-04-05" {
          description
            "Establish semantic version baseline.";
        }
    
        revision "2018-06-15" {
          description
            "Allow min..max in range when min == max.";
        }
    
        revision "2017-06-26" {
          description
            "Change identifiers to be more readable.";
        }
    
        revision "2017-05-01" {
          description
            "Fixing backward compatibility error in module.";
        }
    
        revision "2015-11-09" {
          description "IOS XR 6.0 revision.";
        }
    
        semver:module-version "4.0.0";
        semver:module-version "3.0.0";
        semver:module-version "2.0.0";
    
        typedef Evpn-encapsulation {
          type enumeration {
            enum "evpn-encapsulationvxlan" {
              value 8;
              description "VXLAN Encapsulation";
            }
            enum "evpn-encapsulation-mpls" {
              value 10;
              description "MPLS Encapsulation";
            }
            enum "evpn-encapsulation-route-sync" {
              value 254;
              description
                "Route Sync Encapsulation";
            }
            enum "evpn-encapsulation-srv6" {
              value 255;
              description "SRv6 Encapsulation";
            }
          }
          description "Evpn encapsulation";
        }
    
        typedef Interworking {
          type enumeration {
            enum "ethernet" {
              value 1;
              description
                "Ethernet interworking";
            }
            enum "ipv4" {
              value 3;
              description "IPv4 interworking";
            }
          }
          description "Interworking";
        }
    
        typedef L2vpn-capability-mode {
          type enumeration {
            enum "high-mode" {
              value 1;
              description
                "Compute global capability as the highest node
    capability";
            }
            enum "single-mode" {
              value 2;
              description
                "Disable global capability re-computation";
            }
          }
          description "L2vpn capability mode";
        }
    
        typedef Evpn-side {
          type enumeration {
            enum "evpn-side-regular" {
              value 1;
              description
                "EVPN Instance side defined as regular";
            }
            enum "evpn-side-stitching" {
              value 2;
              description
                "EVPN Instance side defined as stitching";
            }
          }
          description "Evpn side";
        }
    
        typedef Evpnvpws-seamless-integration {
          type enumeration {
            enum "enabled" {
              value 1;
              description
                "EVPN_VPWS Seamless Integration Enabled";
            }
          }
          description
            "Evpnvpws seamless integration";
        }
    
        typedef Vpls-id-addr-index {
          type uint32 {
            range "0..32767";
          }
          description "Vpls id addr index";
        }
    
        typedef Evpn-core-group-id-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Evpn core group id range";
        }
    
        typedef Tag-rewrite-range {
          type uint32 {
            range "1..4094";
          }
          description "Tag rewrite range";
        }
    
        typedef Pseudowire-evpnacid-range {
          type uint32 {
            range "1..16777215";
          }
          description
            "Pseudowire evpnacid range";
        }
    
        typedef Evpnvpnid-range {
          type uint32 {
            range "1..65534";
          }
          description "Evpnvpnid range";
        }
    
        typedef Pseudowire-label-range {
          type uint32 {
            range "16..1048575";
          }
          description "Pseudowire label range";
        }
    
        typedef Bridge-domain-transport-mode {
          type enumeration {
            enum "vlan-passthrough" {
              value 3;
              description
                "Vlan tagged passthrough mode";
            }
          }
          description
            "Bridge domain transport mode";
        }
    
        typedef Preferred-path {
          type enumeration {
            enum "te-tunnel" {
              value 2;
              description "TE Tunnel";
            }
            enum "ip-tunnel" {
              value 3;
              description "IP Tunnel";
            }
            enum "tp-tunnel" {
              value 4;
              description "TP Tunnel";
            }
            enum "sr-te-policy" {
              value 5;
              description "SR TE Policy";
            }
            enum "named-te-tunnel" {
              value 8;
              description "Named TE Tunnel";
            }
          }
          description "Preferred path";
        }
    
        typedef Rd-addr-index {
          type uint32 {
            range "0..65535";
          }
          description "Rd addr index";
        }
    
        typedef Vccv-verification {
          type enumeration {
            enum "none" {
              value 0;
              description
                "No connectivity verification over VCCV";
            }
            enum "lsp-ping" {
              value 2;
              description "LSP Ping over VCCV";
            }
          }
          description "Vccv verification";
        }
    
        typedef L2vpn-mtu-range {
          type uint32 {
            range "64..65535";
          }
          description "L2vpn mtu range";
        }
    
        typedef Mac-secure-shutdown-recovery-time-range {
          type uint32 {
            range "10..3600";
          }
          description
            "Mac secure shutdown recovery time range";
        }
    
        typedef Mac-withdraw-behavior {
          type enumeration {
            enum "legacy" {
              value 1;
              description
                "MAC Withdrawal sent on state-down (legacy)";
            }
            enum "optimized" {
              value 2;
              description
                "Optimized MAC Withdrawal";
            }
          }
          description "Mac withdraw behavior";
        }
    
        typedef Port-down-flush {
          type enumeration {
            enum "port-down-flush" {
              value 0;
              description "MAC Port Down Flush";
            }
            enum "enable-port-down-flush" {
              value 1;
              description
                "Enable Port Down Flush";
            }
            enum "disable-port-down-flush" {
              value 2;
              description
                "Disable Port Down Flush";
            }
          }
          description "Port down flush";
        }
    
        typedef Storm-control-pps-range {
          type uint32 {
            range "1..160000";
          }
          description "Storm control pps range";
        }
    
        typedef Type-of-service-mode {
          type enumeration {
            enum "none" {
              value 0;
              description
                "Do not reflect the type of service";
            }
            enum "reflect" {
              value 1;
              description
                "Reflect the type of service";
            }
          }
          description "Type of service mode";
        }
    
        typedef L2vpn-vs-vlan-tag {
          type uint32 {
            range "1..4094";
          }
          description "L2vpn vs vlan tag";
        }
    
        typedef Pseudowire-tag-range {
          type uint32 {
            range "1..4094";
          }
          description "Pseudowire tag range";
        }
    
        typedef Interface-access-signal-mode {
          type enumeration {
            enum "bundle-down" {
              value 2;
              description "BundleDown";
            }
          }
          description
            "Interface access signal mode";
        }
    
        typedef Multicast-p2mp-signaling {
          type string {
            pattern '(BGP)';
          }
          description "BGP:BGP Signaling";
        }
    
        typedef Cedge-range {
          type uint32 {
            range "11..100";
          }
          description "Cedge range";
        }
    
        typedef Ethernet-segment-load-balance {
          type enumeration {
            enum "single-active" {
              value 1;
              description "Single Active";
            }
            enum "port-active" {
              value 2;
              description "Port Active";
            }
            enum "single-flow-active" {
              value 3;
              description "Single Flow Active";
            }
            enum "all-active" {
              value 4;
              description "All Active";
            }
          }
          description
            "Ethernet segment load balance";
        }
    
        typedef Mpls-signaling-protocol {
          type enumeration {
            enum "none" {
              value 1;
              description "No signaling";
            }
            enum "ldp" {
              value 4;
              description "LDP";
            }
          }
          description "Mpls signaling protocol";
        }
    
        typedef Erpaps {
          type enumeration {
            enum "interface" {
              value 1;
              description
                "ERP APS type interface";
            }
            enum "bridge-domain" {
              value 2;
              description
                "ERP APS type bridge domain";
            }
            enum "xconnect" {
              value 3;
              description
                "ERP APS type xconnect";
            }
            enum "none" {
              value 4;
              description "ERP APS type none";
            }
          }
          description "Erpaps";
        }
    
        typedef Mac-secure-action {
          type enumeration {
            enum "restrict" {
              value 1;
              description
                "MAC Secure Action Restrict";
            }
            enum "none" {
              value 2;
              description "No Action";
            }
            enum "shutdown" {
              value 3;
              description
                "MAC Secure Action Shutdown";
            }
          }
          description "Mac secure action";
        }
    
        typedef Erp-port {
          type enumeration {
            enum "none" {
              value 1;
              description "ERP port type none";
            }
            enum "virtual" {
              value 2;
              description
                "ERP port type virtual";
            }
            enum "interface" {
              value 3;
              description
                "ERP port type interface";
            }
          }
          description "Erp port";
        }
    
        typedef Resync-threshold-range {
          type uint32 {
            range "5..65535";
          }
          description "Resync threshold range";
        }
    
        typedef Bgp-route-target-role {
          type enumeration {
            enum "both" {
              value 0;
              description
                "Both Import and export roles";
            }
            enum "import" {
              value 1;
              description "Import role";
            }
            enum "export" {
              value 2;
              description "Export role";
            }
          }
          description "Bgp route target role";
        }
    
        typedef Backup-disable {
          type enumeration {
            enum "never" {
              value 0;
              description "Never";
            }
            enum "delay" {
              value 1;
              description "Delay seconds";
            }
          }
          description "Backup disable";
        }
    
        typedef Time-to-live-range {
          type uint32 {
            range "1..255";
          }
          description "Time to live range";
        }
    
        typedef Multicast-p2mp-transport {
          type string {
            pattern '(RSVP_TE)';
          }
          description
            "RSVP_TE:RSVP-TE Transport";
        }
    
        typedef Transport-mode {
          type enumeration {
            enum "ethernet" {
              value 1;
              description "Ethernet port mode";
            }
            enum "vlan" {
              value 2;
              description "Vlan tagged mode";
            }
            enum "vlan-passthrough" {
              value 3;
              description
                "Vlan tagged passthrough mode";
            }
          }
          description "Transport mode";
        }
    
        typedef Flow-label-tlv-code {
          type enumeration {
            enum "17" {
              value 4;
              description
                "Set Flow Label Legacy TLV code (DEPRECATED)";
            }
            enum "disable" {
              value 8;
              description
                "Disable Sending Flow Label Legacy TLV";
            }
          }
          description "Flow label tlv code";
        }
    
        typedef Bgp-route-target {
          type enumeration {
            enum "no-stitching" {
              value 0;
              description "RT is default type";
            }
            enum "stitching" {
              value 1;
              description
                "RT is for stitching (Golf-L2) (DEPRECATED)";
            }
          }
          description "Bgp route target";
        }
    
        typedef Pseudowire-acid-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Pseudowire acid range";
        }
    
        typedef Pseudowire-id-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Pseudowire id range";
        }
    
        typedef Interface-profile {
          type enumeration {
            enum "snoop" {
              value 1;
              description "Set the snooping";
            }
            enum "dhcp-protocol" {
              value 2;
              description
                "disable DHCP protocol";
            }
          }
          description "Interface profile";
        }
    
        typedef Ethernet-segment-identifier {
          type enumeration {
            enum "type0" {
              value 0;
              description "ESI type 0";
            }
            enum "legacy" {
              value 128;
              description "Legacy ESI type";
            }
            enum "override" {
              value 129;
              description "Override ESI type";
            }
          }
          description
            "Ethernet segment identifier";
        }
    
        typedef Rpl-role {
          type enumeration {
            enum "owner" {
              value 1;
              description "ERP RPL owner";
            }
            enum "neighbor" {
              value 2;
              description "ERP RPL neighbor";
            }
            enum "next-neighbor" {
              value 3;
              description
                "ERP RPL next neighbor";
            }
          }
          description "Rpl role";
        }
    
        typedef Pw-switching-point-tlv {
          type enumeration {
            enum "hide" {
              value 2;
              description "Hide TLV";
            }
          }
          description "Pw switching point tlv";
        }
    
        typedef Erpaps-level-range {
          type uint32 {
            range "0..7";
          }
          description "Erpaps level range";
        }
    
        typedef Evpn-esi-type-range {
          type uint32 {
            range "1";
          }
          description "Evpn esi type range";
        }
    
        typedef Storm-control {
          type enumeration {
            enum "unicast" {
              value 1;
              description
                "Unknown-unicast Storm Control";
            }
            enum "multicast" {
              value 2;
              description
                "Multicast Storm Control";
            }
            enum "broadcast" {
              value 4;
              description
                "Broadcast Storm Control";
            }
          }
          description "Storm control";
        }
    
        typedef L2tp-session-id-range {
          type uint32 {
            range "1..65535";
          }
          description "L2tp session id range";
        }
    
        typedef Ethernet-segment-service-carving {
          type enumeration {
            enum "mod-n" {
              value 0;
              description "MOD N";
            }
            enum "manual" {
              value 1;
              description "Manual";
            }
            enum "hrw" {
              value 2;
              description "HRW";
            }
            enum "pref-df" {
              value 3;
              description "PrefDF";
            }
          }
          description
            "Ethernet segment service carving";
        }
    
        typedef Mac-learn {
          type enumeration {
            enum "default-learning" {
              value 0;
              description "Mac Learning";
            }
            enum "enable-learning" {
              value 1;
              description "Enable Learning";
            }
            enum "disable-learning" {
              value 2;
              description "Disable Learning";
            }
          }
          description "Mac learn";
        }
    
        typedef L2tpv3-sequencing {
          type enumeration {
            enum "off" {
              value 0;
              description "Sequencing is off";
            }
            enum "both" {
              value 4;
              description
                "Sequencing on both transmit and receive side";
            }
          }
          description "L2tpv3 sequencing";
        }
    
        typedef Veid-range {
          type uint32 {
            range "1..16384";
          }
          description "Veid range";
        }
    
        typedef Load-balance {
          type enumeration {
            enum "source-dest-mac" {
              value 1;
              description
                "Source and Destination MAC hashing";
            }
            enum "source-dest-ip" {
              value 2;
              description
                "Source and Destination IP hashing";
            }
            enum "pseudowire-label" {
              value 4;
              description "PW Label hashing";
            }
          }
          description "Load balance";
        }
    
        typedef L2tp-signaling-protocol {
          type enumeration {
            enum "none" {
              value 1;
              description "No signaling";
            }
            enum "l2tpv3" {
              value 2;
              description "L2TPv3";
            }
          }
          description "L2tp signaling protocol";
        }
    
        typedef Bdmac-learn {
          type enumeration {
            enum "disable-learning" {
              value 2;
              description "Disable Learning";
            }
          }
          description "Bdmac learn";
        }
    
        typedef L2mc-src-traffic-enabled {
          type enumeration {
            enum "l2mc-none" {
              value 0;
              description "NONE";
            }
            enum "l2mc-ipv4" {
              value 1;
              description
                "Multicast Source - IPv4";
            }
            enum "l2mc-ipv6" {
              value 2;
              description
                "Multicast Source - IPv6";
            }
            enum "l2mc-ipv4-ipv6" {
              value 3;
              description
                "Multicast Source - IPv4 IPv6";
            }
          }
          description "L2mc src traffic enabled";
        }
    
        typedef L2vpn-verification {
          type enumeration {
            enum "enable" {
              value 1;
              description "enable verification";
            }
            enum "disable" {
              value 2;
              description "disable verification";
            }
          }
          description "L2vpn verification";
        }
    
        typedef Max-path-mtu-range {
          type uint32 {
            range "68..65535";
          }
          description "Max path mtu range";
        }
    
        typedef Interface-traffic-flood {
          type enumeration {
            enum "traffic-flooding" {
              value 0;
              description "Traffic flooding";
            }
            enum "enable-flooding" {
              value 1;
              description "Enable Flooding";
            }
            enum "disable-flooding" {
              value 2;
              description "Disable flooding";
            }
          }
          description "Interface traffic flood";
        }
    
        typedef Pbbvid-range {
          type uint32 {
            range "1..4094";
          }
          description "Pbbvid range";
        }
    
        typedef L2tp-cookie-value-range {
          type uint32 {
            range "0..4294967295";
          }
          description "L2tp cookie value range";
        }
    
        typedef L2-encapsulation {
          type enumeration {
            enum "vlan" {
              value 4;
              description "Vlan tagged mode";
            }
            enum "ethernet" {
              value 5;
              description "Ethernet port mode";
            }
          }
          description "L2 encapsulation";
        }
    
        typedef L2vpn-logging {
          type enumeration {
            enum "enable" {
              value 1;
              description "enable logging";
            }
            enum "disable" {
              value 2;
              description "disable logging";
            }
          }
          description "L2vpn logging";
        }
    
        typedef Mac-aging-range {
          type uint32 {
            range "300..30000";
          }
          description "Mac aging range";
        }
    
        typedef Vpls-id-as-index {
          type uint32 {
            range "0..4294967295";
          }
          description "Vpls id as index";
        }
    
        typedef Pseudowire-gbl-id-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Pseudowire gbl id range";
        }
    
        typedef Rdas-index {
          type uint32 {
            range "0..4294967295";
          }
          description "Rdas index";
        }
    
        typedef Mac-flush-mode {
          type enumeration {
            enum "mvrp" {
              value 1;
              description "MVRP MAC Flushing";
            }
          }
          description "Mac flush mode";
        }
    
        typedef L2tp-cookie-size {
          type enumeration {
            enum "zero" {
              value 0;
              description
                "Cookie size is zero bytes";
            }
            enum "four" {
              value 4;
              description
                "Cookie size is four bytes";
            }
            enum "eight" {
              value 8;
              description
                "Cookie size is eight bytes";
            }
          }
          description "L2tp cookie size";
        }
    
        typedef Mpls-sequencing {
          type enumeration {
            enum "off" {
              value 0;
              description "Sequencing is off";
            }
            enum "transmit" {
              value 1;
              description
                "Sequencing on transmit side";
            }
            enum "receive" {
              value 2;
              description
                "Sequencing on receive side";
            }
            enum "both" {
              value 4;
              description
                "Sequencing on both transmit and receive side";
            }
          }
          description "Mpls sequencing";
        }
    
        typedef Erp-instance-range {
          type uint32 {
            range "1..2";
          }
          description "Erp instance range";
        }
    
        typedef Pw-redundancy-initial-delay-range {
          type uint32 {
            range "0..120";
          }
          description
            "Pw redundancy initial delay range";
        }
    
        typedef Vpls-id-as-range {
          type uint32 {
            range "1..65535";
          }
          description "Vpls id as range";
        }
    
        typedef Rdas-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Rdas range";
        }
    
        typedef Ethernet-segment-service-carving-mcast {
          type enumeration {
            enum "disabled" {
              value 0;
              description "Disabled";
            }
            enum "hrw-s-g" {
              value 1;
              description "HRW S G";
            }
            enum "hrw-g" {
              value 2;
              description "HRW G";
            }
          }
          description
            "Ethernet segment service carving mcast";
        }
    
        typedef Bridge-bd-mtu-range {
          type uint32 {
            range "46..65535";
          }
          description "Bridge bd mtu range";
        }
    
        typedef Backup-disable-delay-range {
          type uint32 {
            range "0..180";
          }
          description
            "Backup disable delay range";
        }
    
        typedef Storm-control-kbps-range {
          type uint32 {
            range "64..1280000";
          }
          description "Storm control kbps range";
        }
    
        typedef Mac-limit-action {
          type enumeration {
            enum "none" {
              value 0;
              description "No action";
            }
            enum "flood" {
              value 1;
              description
                "Flood Mac Limit Action";
            }
            enum "no-flood" {
              value 2;
              description
                "NoFlood Mac Limit Action";
            }
            enum "shutdown" {
              value 3;
              description
                "Shutdown Mac Limit Action";
            }
          }
          description "Mac limit action";
        }
    
        typedef Erp-port1 {
          type enumeration {
            enum "port0" {
              value 0;
              description "ERP main port 0";
            }
            enum "port1" {
              value 1;
              description "ERP main port 1";
            }
          }
          description "Erp port1";
        }
    
        typedef Mac-notification {
          type enumeration {
            enum "no-notif" {
              value 0;
              description "No_Notification Trap";
            }
            enum "syslog" {
              value 1;
              description "syslog message";
            }
            enum "trap" {
              value 2;
              description "Snmp Trap";
            }
            enum "syslog-snmp" {
              value 3;
              description "Syslog_snmp Trap";
            }
          }
          description "Mac notification";
        }
    
        typedef Control-word {
          type enumeration {
            enum "enable" {
              value 1;
              description "Enable control word";
            }
            enum "disable" {
              value 2;
              description "Disable control word";
            }
          }
          description "Control word";
        }
    
        typedef Preferred-nexthop-mode {
          type enumeration {
            enum "preferred-nexthop-lowest-ip" {
              value 1;
              description "Lowest IP Preferred";
            }
            enum "preferred-nexthop-highest-ip" {
              value 2;
              description "Highest IP Preferred";
            }
            enum "preferred-nexthop-modulo" {
              value 3;
              description
                "Modulo of nexthops Preferred";
            }
          }
          description "Preferred nexthop mode";
        }
    
        typedef Bgp-route-distinguisher {
          type enumeration {
            enum "auto" {
              value 1;
              description
                "RD automatically assigned";
            }
            enum "two-byte-as" {
              value 2;
              description
                "RD in 2 byte AS:nn format";
            }
            enum "four-byte-as" {
              value 3;
              description
                "RD in 4 byte AS:nn format";
            }
            enum "ipv4-address" {
              value 4;
              description "RD in IpV4address";
            }
          }
          description "Bgp route distinguisher";
        }
    
        typedef Bgp-route-target-format {
          type enumeration {
            enum "none" {
              value 0;
              description "No route target";
            }
            enum "two-byte-as" {
              value 1;
              description "2 Byte AS:nn format";
            }
            enum "four-byte-as" {
              value 2;
              description "4 byte AS:nn format";
            }
            enum "ipv4-address" {
              value 3;
              description "IP:nn format";
            }
            enum "es-import" {
              value 1538;
              description "a.a.i format";
            }
          }
          description "Bgp route target format";
        }
    
        typedef Evpn-group-id-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Evpn group id range";
        }
    
        typedef Mac-limit-threshold-range {
          type uint32 {
            range "1..100";
          }
          description
            "Mac limit threshold range";
        }
    
        typedef Vedge-range {
          type uint32 {
            range "11..100";
          }
          description "Vedge range";
        }
    
        typedef Vpnid-range {
          type uint32 {
            range "1..4294967295";
          }
          description "Vpnid range";
        }
    
        typedef Ldp-vpls-id {
          type enumeration {
            enum "two-byte-as" {
              value 10;
              description
                "VPLS-ID in 2 byte AS:nn format";
            }
            enum "ipv4-address" {
              value 266;
              description
                "VPLS-ID in IPv4 IP:nn format";
            }
          }
          description "Ldp vpls id";
        }
    
        typedef Ce-id-range {
          type uint32 {
            range "1..16384";
          }
          description "Ce id range";
        }
    
        typedef Mac-aging {
          type enumeration {
            enum "absolute" {
              value 1;
              description "Absolute aging type";
            }
            enum "inactivity" {
              value 2;
              description
                "Inactivity aging type";
            }
          }
          description "Mac aging";
        }
    
        typedef Mac-limit-range {
          type uint32 {
            range "0..4294967295";
          }
          description "Mac limit range";
        }
    
        typedef Pbbisid-range {
          type uint32 {
            range "256..16777214";
          }
          description "Pbbisid range";
        }
    
        typedef Type-of-service-range {
          type uint32 {
            range "0..255";
          }
          description "Type of service range";
        }
    
        typedef Flow-label-load-balance {
          type enumeration {
            enum "off" {
              value 0;
              description
                "Flow Label load balance is off";
            }
            enum "receive" {
              value 1;
              description
                "Delete Flow Label on receive side";
            }
            enum "transmit" {
              value 2;
              description
                "Insert Flow Label on transmit side";
            }
            enum "both" {
              value 3;
              description
                "Insert/Delete Flow Label on transmit/receive
    side";
            }
          }
          description "Flow label load balance";
        }
    
        container l2vpn {
          description "L2VPN configuration";
          container pw-routing {
            description
              "Pseudowire-routing attributes";
            container pw-routing-bgp {
              description
                "Enable Autodiscovery BGP Pseudowire-routing BGP";
              leaf enable {
                type empty;
                description
                  "Enable Autodiscovery BGP";
              }
    
              container evpn-route-distinguisher {
                description
                  "Route Distinguisher";
                leaf type {
                  type Bgp-route-distinguisher;
                  description
                    "Router Distinguisher Type";
                }
    
                leaf as {
                  when
                    "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                    description
                      "../Type = TwoByteAS or ../Type = FourByteAS";
                  }
                  type Rdas-range;
                  description
                    "Two byte or 4 byte AS number";
                }
    
                leaf as-index {
                  when
                    "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                    description
                      "../Type = TwoByteAS or ../Type = FourByteAS";
                  }
                  type Rdas-index;
                  description
                    "AS:nn (hex or decimal format)";
                }
    
                leaf address {
                  when
                    "../type = 'ipv4-address'" {
                    description
                      "../Type = IPV4Address";
                  }
                  type inet:ipv4-address-no-zone;
                  description "IPV4 address";
                }
    
                leaf addr-index {
                  when
                    "../type = 'ipv4-address'" {
                    description
                      "../Type = IPV4Address";
                  }
                  type Rd-addr-index;
                  description "Addr index";
                }
              }  // container evpn-route-distinguisher
            }  // container pw-routing-bgp
    
            leaf pw-routing-global-id {
              type Pseudowire-gbl-id-range;
              description
                "Pseudowire-routing Global ID";
            }
          }  // container pw-routing
    
          container neighbor {
            description "L2VPN neighbor submode";
            leaf ldp-flap {
              type empty;
              description
                "Enable targetted LDP session flap action";
            }
          }  // container neighbor
    
          container database {
            description "L2VPN databases";
            container g8032-rings {
              description "List of G8032 Ring";
              list g8032-ring {
                key "g8032-ring-name";
                description "G8032 Ring";
                container erp-port0s {
                  description
                    "Ethernet ring protection port0";
                  list erp-port0 {
                    key "interface-name";
                    description
                      "Configure ERP main port0";
                    leaf monitor {
                      type xr:Interface-name;
                      description
                        "Ethernet ring protection port0 monitor";
                    }
    
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Port0 interface";
                    }
                  }  // list erp-port0
                }  // container erp-port0s
    
                container erp-instances {
                  description
                    "List of ethernet ring protection instance";
                  list erp-instance {
                    key "erp-instance-id";
                    description
                      "Ethernet ring protection instance";
                    container rpl {
                      description
                        "Ring protection link";
                      leaf port {
                        type Erp-port1;
                        description
                          "ERP main port number";
                      }
    
                      leaf role {
                        type Rpl-role;
                        description "RPL role";
                      }
                    }  // container rpl
    
                    container aps {
                      description
                        "Automatic protection switching";
                      container port1 {
                        description
                          "APS channel for ERP port1";
                        leaf aps-type {
                          type Erpaps;
                          description
                            "Port1 APS type";
                        }
    
                        leaf aps-channel {
                          type string;
                          description
                            "Port1 APS channel in the format of
    InterfaceName, BDName or XconnectName";
                        }
                      }  // container port1
    
                      leaf port0 {
                        type string;
                        description
                          "Port0 APS channel in the format of
    InterfaceName";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable automatic protection switching";
                      }
    
                      leaf level {
                        type Erpaps-level-range;
                        description
                          "Automatic protection switching level";
                      }
                    }  // container aps
    
                    leaf description {
                      type string {
                        length "1..32";
                      }
                      description
                        "Ethernet ring protection instance
    description";
                    }
    
                    leaf inclusion-list {
                      type string;
                      description
                        "Associates a set of VLAN IDs with the G
    .8032 instance";
                    }
    
                    leaf profile {
                      type string {
                        length "1..32";
                      }
                      description
                        "Ethernet ring protection instance profile";
                    }
    
                    leaf erp-instance-id {
                      type Erp-instance-range;
                      description
                        "ERP instance number";
                    }
                  }  // list erp-instance
                }  // container erp-instances
    
                container erp-port1s {
                  description
                    "Ethernet ring protection port0";
                  list erp-port1 {
                    must
                      "none-or-virtual or interface" {
                      description
                        "None-or-Virtual or Interface must be
    present.";
                    }
                    key "erp-port-type";
                    description
                      "Ethernet ring protection port1";
                    container none-or-virtual {
                      when
                        "../erp-port-type = 'none' or ../erp-port-type = 'virtual'" {
                        description
                          "../ERPPortType = None or ../ERPPortType =
    Virtual";
                      }
                      presence
                        "Indicates that this node is configured.";
                      description
                        "none or virtual";
                      leaf monitor {
                        type xr:Interface-name;
                        description
                          "Ethernet ring protection port1 monitor";
                      }
                    }  // container none-or-virtual
    
                    leaf erp-port-type {
                      type Erp-port;
                      description "Port1 type";
                    }
    
                    list interface {
                      when
                        "../erp-port-type = 'interface'" {
                        description
                          "../ERPPortType = Interface";
                      }
                      key "interface-name";
                      description "interface";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Port1 interface";
                      }
    
                      leaf monitor {
                        type xr:Interface-name;
                        description
                          "Ethernet ring protection port1 monitor";
                      }
                    }  // list interface
                  }  // list erp-port1
                }  // container erp-port1s
    
                leaf open-ring {
                  type empty;
                  description
                    "Specify the G.8032 instance as open ring";
                }
    
                leaf exclusion-list {
                  type string;
                  description
                    "Vlan IDs in the format of a-b,c,d,e-f,g
    ,untagged";
                }
    
                leaf erp-provider-bridge {
                  type empty;
                  description
                    "Ethernet ring protection provider bridge";
                }
    
                leaf g8032-ring-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Name of the G8032 ring";
                }
              }  // list g8032-ring
            }  // container g8032-rings
    
            container xconnect-groups {
              description
                "List of xconnect groups";
              list xconnect-group {
                key "name";
                description "Xconnect group";
                container p2p-xconnects {
                  description
                    "List of point to point xconnects";
                  list p2p-xconnect {
                    key "name";
                    description
                      "Point to point xconnect";
                    container pseudowire-evpn-srv6s {
                      description
                        "List of EVPN SRv6 Services";
                      list pseudowire-evpn-srv6 {
                        key "eviid remote-acid source-acid";
                        description
                          "EVPN SRv6 P2P Service Configuration";
                        leaf pseudowire-evpn-srv6-locator {
                          type xr:Cisco-ios-xr-string {
                            length "1..58";
                          }
                          description
                            "Specify SRv6 locator name";
                        }
    
                        leaf eviid {
                          type Evpnvpnid-range;
                          description
                            "Ethernet VPN ID";
                        }
    
                        leaf remote-acid {
                          type Pseudowire-evpnacid-range;
                          description
                            "Remote AC ID";
                        }
    
                        leaf source-acid {
                          type Pseudowire-evpnacid-range;
                          description
                            "Source AC ID";
                        }
                      }  // list pseudowire-evpn-srv6
                    }  // container pseudowire-evpn-srv6s
    
                    container pseudowire-evpn-srv6-services {
                      description
                        "List of EVPN SRv6 Services keyed by EVI and
    Service ID";
                      list pseudowire-evpn-srv6-service {
                        key "eviid service-id";
                        description
                          "EVPN SRv6 P2P Service Configuration";
                        leaf pseudowire-evpn-srv6-locator {
                          type xr:Cisco-ios-xr-string {
                            length "1..58";
                          }
                          description
                            "Specify SRv6 locator name";
                        }
    
                        leaf eviid {
                          type Evpnvpnid-range;
                          description
                            "Ethernet VPN ID";
                        }
    
                        leaf service-id {
                          type Pseudowire-evpnacid-range;
                          description
                            "Service ID (Target and Source AC ID)";
                        }
                      }  // list pseudowire-evpn-srv6-service
                    }  // container pseudowire-evpn-srv6-services
    
                    container backup-attachment-circuits {
                      description
                        "List of backup attachment circuits";
                      list backup-attachment-circuit {
                        key "interface-name";
                        description
                          "Backup attachment circuit";
                        leaf interface-name {
                          type xr:Interface-name;
                          description
                            "Name of the attachment circuit interface";
                        }
                      }  // list backup-attachment-circuit
                    }  // container backup-attachment-circuits
    
                    container pseudowire-evpns {
                      description
                        "List of EVPN Services";
                      list pseudowire-evpn {
                        key "eviid remote-acid source-acid";
                        description
                          "EVPN P2P Service Configuration";
                        leaf class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the pseudowire class";
                        }
    
                        leaf eviid {
                          type Evpnvpnid-range;
                          description
                            "Ethernet VPN ID";
                        }
    
                        leaf remote-acid {
                          type Pseudowire-evpnacid-range;
                          description
                            "Remote AC ID";
                        }
    
                        leaf source-acid {
                          type Pseudowire-evpnacid-range;
                          description
                            "Source AC ID";
                        }
                      }  // list pseudowire-evpn
                    }  // container pseudowire-evpns
    
                    container pseudowire-neighbor-pseudowire-ids {
                      description
                        "List of pseudowires";
                      list pseudowire-neighbor-pseudowire-id {
                        key "neighbor pseudowire-id";
                        description
                          "Pseudowire configuration";
                        leaf neighbor {
                          type inet:ipv4-address-no-zone;
                          description
                            "Pseudowire IPv4 address";
                        }
    
                        leaf pseudowire-id {
                          type Pseudowire-id-range;
                          description
                            "Pseudowire ID";
                        }
    
                        container mpls-static-labels {
                          description
                            "MPLS static labels";
                          leaf local-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire local static label";
                          }
    
                          leaf remote-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire remote static label";
                          }
                        }  // container mpls-static-labels
    
                        container backup-pseudowires {
                          description
                            "List of pseudowires";
                          list backup-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Backup pseudowire for the cross connect";
                            container backup-mpls-static-labels {
                              description
                                "MPLS static labels";
                              leaf local-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire local static label";
                              }
    
                              leaf remote-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire remote static label";
                              }
                            }  // container backup-mpls-static-labels
    
                            leaf backup-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "PW class template name to use for the
    backup PW";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list backup-pseudowire
                        }  // container backup-pseudowires
    
                        container l2tp-static-attributes {
                          description
                            "L2TP Static Attributes";
                          container l2tp-remote-cookie {
                            description
                              "L2TP remote cookie";
                            leaf size {
                              type L2tp-cookie-size;
                              description
                                "Remote cookie size";
                            }
    
                            leaf lower-value {
                              type L2tp-cookie-value-range;
                              description
                                "Lower remote cookie value";
                            }
    
                            leaf higher-value {
                              type L2tp-cookie-value-range;
                              description
                                "Higher remote cookie value";
                            }
                          }  // container l2tp-remote-cookie
    
                          container l2tp-secondary-local-cookie {
                            description
                              "L2TP secondary local cookie";
                            leaf size {
                              type L2tp-cookie-size;
                              description
                                "Local cookie size";
                            }
    
                            leaf lower-value {
                              type L2tp-cookie-value-range;
                              description
                                "Lower local cookie value";
                            }
    
                            leaf higher-value {
                              type L2tp-cookie-value-range;
                              description
                                "Higher local cookie value";
                            }
                          }  // container l2tp-secondary-local-cookie
    
                          container l2tp-local-cookie {
                            description
                              "L2TP local cookie";
                            leaf size {
                              type L2tp-cookie-size;
                              description
                                "Local cookie size";
                            }
    
                            leaf lower-value {
                              type L2tp-cookie-value-range;
                              description
                                "Lower local cookie value";
                            }
    
                            leaf higher-value {
                              type L2tp-cookie-value-range;
                              description
                                "Higher local cookie value";
                            }
                          }  // container l2tp-local-cookie
    
                          leaf l2tp-remote-session-id {
                            type L2tp-session-id-range;
                            description
                              "L2TP remote session ID";
                          }
    
                          leaf l2tp-local-session-id {
                            type L2tp-session-id-range;
                            description
                              "L2TP local session ID";
                          }
                        }  // container l2tp-static-attributes
    
                        container l2tp-static {
                          description
                            "Pseudowire L2TPv3 static configuration";
                          leaf enable {
                            type empty;
                            description
                              "Enable pseudowire L2TPv3 static
    configuration";
                          }
                        }  // container l2tp-static
    
                        leaf tag-impose {
                          type Pseudowire-tag-range;
                          description
                            "Tag Impose vlan tagged mode";
                        }
    
                        leaf class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the pseudowire class";
                        }
    
                        leaf source-address {
                          type inet:ip-address-no-zone;
                          description
                            "Value of the Pseudowire source address.
    Must be IPv6 only.";
                        }
    
                        leaf bandwidth {
                          type uint32 {
                            range
                              "0..4294967295";
                          }
                          description
                            "Pseudowire Bandwidth";
                        }
                      }  // list pseudowire-neighbor-pseudowire-id
    
                      list pseudowire-pseudowire-address-pseudowire-id {
                        key "pseudowire-address pseudowire-id";
                        description
                          "Pseudowire configuration";
                        leaf pseudowire-address {
                          type inet:ipv6-address-no-zone;
                          description
                            "Pseudowire IPv6 address. A pseudowire can
    have only one address: IPv4 or IPv6";
                        }
    
                        leaf pseudowire-id {
                          type Pseudowire-id-range;
                          description
                            "Pseudowire ID";
                        }
    
                        container mpls-static-labels {
                          description
                            "MPLS static labels";
                          leaf local-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire local static label";
                          }
    
                          leaf remote-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire remote static label";
                          }
                        }  // container mpls-static-labels
    
                        container backup-pseudowires {
                          description
                            "List of pseudowires";
                          list backup-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Backup pseudowire for the cross connect";
                            container backup-mpls-static-labels {
                              description
                                "MPLS static labels";
                              leaf local-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire local static label";
                              }
    
                              leaf remote-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire remote static label";
                              }
                            }  // container backup-mpls-static-labels
    
                            leaf backup-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "PW class template name to use for the
    backup PW";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list backup-pseudowire
                        }  // container backup-pseudowires
    
                        container l2tp-static-attributes {
                          description
                            "L2TP Static Attributes";
                          container l2tp-remote-cookie {
                            description
                              "L2TP remote cookie";
                            leaf size {
                              type L2tp-cookie-size;
                              description
                                "Remote cookie size";
                            }
    
                            leaf lower-value {
                              type L2tp-cookie-value-range;
                              description
                                "Lower remote cookie value";
                            }
    
                            leaf higher-value {
                              type L2tp-cookie-value-range;
                              description
                                "Higher remote cookie value";
                            }
                          }  // container l2tp-remote-cookie
    
                          container l2tp-secondary-local-cookie {
                            description
                              "L2TP secondary local cookie";
                            leaf size {
                              type L2tp-cookie-size;
                              description
                                "Local cookie size";
                            }
    
                            leaf lower-value {
                              type L2tp-cookie-value-range;
                              description
                                "Lower local cookie value";
                            }
    
                            leaf higher-value {
                              type L2tp-cookie-value-range;
                              description
                                "Higher local cookie value";
                            }
                          }  // container l2tp-secondary-local-cookie
    
                          container l2tp-local-cookie {
                            description
                              "L2TP local cookie";
                            leaf size {
                              type L2tp-cookie-size;
                              description
                                "Local cookie size";
                            }
    
                            leaf lower-value {
                              type L2tp-cookie-value-range;
                              description
                                "Lower local cookie value";
                            }
    
                            leaf higher-value {
                              type L2tp-cookie-value-range;
                              description
                                "Higher local cookie value";
                            }
                          }  // container l2tp-local-cookie
    
                          leaf l2tp-remote-session-id {
                            type L2tp-session-id-range;
                            description
                              "L2TP remote session ID";
                          }
    
                          leaf l2tp-local-session-id {
                            type L2tp-session-id-range;
                            description
                              "L2TP local session ID";
                          }
                        }  // container l2tp-static-attributes
    
                        container l2tp-static {
                          description
                            "Pseudowire L2TPv3 static configuration";
                          leaf enable {
                            type empty;
                            description
                              "Enable pseudowire L2TPv3 static
    configuration";
                          }
                        }  // container l2tp-static
    
                        leaf tag-impose {
                          type Pseudowire-tag-range;
                          description
                            "Tag Impose vlan tagged mode";
                        }
    
                        leaf class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the pseudowire class";
                        }
    
                        leaf source-address {
                          type inet:ip-address-no-zone;
                          description
                            "Value of the Pseudowire source address.
    Must be IPv6 only.";
                        }
    
                        leaf bandwidth {
                          type uint32 {
                            range
                              "0..4294967295";
                          }
                          description
                            "Pseudowire Bandwidth";
                        }
                      }  // list pseudowire-pseudowire-address-pseudowire-id
                    }  // container pseudowire-neighbor-pseudowire-ids
    
                    container monitor-sessions {
                      description
                        "List of Monitor session segments";
                      list monitor-session {
                        key "name";
                        description
                          "Monitor session segment";
                        leaf enable {
                          type empty;
                          description
                            "Enable monitor session segment ";
                        }
    
                        leaf name {
                          type xr:Cisco-ios-xr-string {
                            length "1..64";
                          }
                          description
                            "Name of the monitor session";
                        }
                      }  // list monitor-session
                    }  // container monitor-sessions
    
                    container pseudowire-routeds {
                      description
                        "List of pseudowire-routed";
                      list pseudowire-routed {
                        key "global-id prefix acid sacid";
                        description
                          "Pseudowire configuration";
                        leaf tag-impose {
                          type Pseudowire-tag-range;
                          description
                            "Tag Impose vlan tagged mode";
                        }
    
                        leaf class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the pseudowire class";
                        }
    
                        leaf global-id {
                          type Pseudowire-gbl-id-range;
                          description
                            "Target Global ID";
                        }
    
                        leaf prefix {
                          type inet:ipv4-address-no-zone;
                          description
                            "Target Prefix";
                        }
    
                        leaf acid {
                          type Pseudowire-acid-range;
                          description
                            "Target AC ID";
                        }
    
                        leaf sacid {
                          type Pseudowire-acid-range;
                          description
                            "Source AC ID";
                        }
                      }  // list pseudowire-routed
                    }  // container pseudowire-routeds
    
                    container pseudowire-evpn-services {
                      description
                        "List of EVPN Services keyed by EVI and
    Service ID";
                      list pseudowire-evpn-service {
                        key "eviid service-id";
                        description
                          "EVPN P2P Service Configuration";
                        leaf class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the pseudowire class";
                        }
    
                        leaf eviid {
                          type Evpnvpnid-range;
                          description
                            "Ethernet VPN ID";
                        }
    
                        leaf service-id {
                          type Pseudowire-evpnacid-range;
                          description
                            "Service ID (Remote and Source AC ID)";
                        }
                      }  // list pseudowire-evpn-service
                    }  // container pseudowire-evpn-services
    
                    container attachment-circuits {
                      description
                        "List of attachment circuits";
                      list attachment-circuit {
                        key "name";
                        description
                          "Attachment circuit interface";
                        leaf enable {
                          type empty;
                          description
                            "Enable attachment circuit interface";
                        }
    
                        leaf name {
                          type xr:Interface-name;
                          description
                            "Name of the attachment circuit interface";
                        }
                      }  // list attachment-circuit
                    }  // container attachment-circuits
    
                    leaf evpnvpws-seamless-integration {
                      type Evpnvpws-seamless-integration;
                      description
                        "Description for EVPN-VPWS Seamless
    Integration with Legacy VPWS";
                    }
    
                    leaf p2p-description {
                      type string {
                        length "1..64";
                      }
                      description
                        "cross connect description Name";
                    }
    
                    leaf interworking {
                      type Interworking;
                      description "Interworking";
                    }
    
                    leaf name {
                      type xr:Cisco-ios-xr-string {
                        length "1..38";
                      }
                      description
                        "Name of the point to point xconnect";
                    }
                  }  // list p2p-xconnect
                }  // container p2p-xconnects
    
                container mp2mp-xconnects {
                  description
                    "List of multi point to multi point xconnects";
                  list mp2mp-xconnect {
                    key "name";
                    description
                      "Multi point to multi point xconnect";
                    container mp2mp-auto-discovery {
                      description
                        "auto-discovery in this MP2MP";
                      container route-distinguisher {
                        description
                          "Route Distinguisher";
                        leaf type {
                          type Bgp-route-distinguisher;
                          description
                            "Router distinguisher type";
                        }
    
                        leaf as {
                          when
                            "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                            description
                              "../Type = TwoByteAS or ../Type =
    FourByteAS";
                          }
                          type Rdas-range;
                          description
                            "Two byte or 4 byte AS number";
                        }
    
                        leaf as-index {
                          when
                            "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                            description
                              "../Type = TwoByteAS or ../Type =
    FourByteAS";
                          }
                          type Rdas-index;
                          description
                            "AS:nn (hex or decimal format)";
                        }
    
                        leaf address {
                          when
                            "../type = 'ipv4-address'" {
                            description
                              "../Type = IPV4Address";
                          }
                          type inet:ipv4-address-no-zone;
                          description
                            "IPV4 address";
                        }
    
                        leaf addr-index {
                          when
                            "../type = 'ipv4-address'" {
                            description
                              "../Type = IPV4Address";
                          }
                          type Rd-addr-index;
                          description
                            "Addr index";
                        }
                      }  // container route-distinguisher
    
                      container mp2mp-route-policy {
                        description
                          "Route policy";
                        leaf export {
                          type string;
                          description
                            "Export route policy";
                        }
                      }  // container mp2mp-route-policy
    
                      container mp2mp-route-targets {
                        description
                          "Route Target";
                        list mp2mp-route-target {
                          must
                            "two-byte-as-or-four-byte-as or ipv4-address" {
                            description
                              "TwoByteAS-or-FourbyteAS or IPV4Address
    must be present.";
                          }
                          key "role format";
                          description
                            "Name of the Route Target";
                          leaf role {
                            type Bgp-route-target-role;
                            description
                              "Role of the router target type";
                          }
    
                          leaf format {
                            type Bgp-route-target-format;
                            description
                              "Format of the route target";
                          }
    
                          list two-byte-as-or-four-byte-as {
                            when
                              "../format = 'two-byte-as' or ../format = 'four-byte-as'" {
                              description
                                "../Format = TwoByteAS or ../Format =
    FourbyteAS";
                            }
                            key "as as-index";
                            description
                              "two byte as or four byte as";
                            leaf as {
                              type Rdas-range;
                              description
                                "Two byte or 4 byte AS number";
                            }
    
                            leaf as-index {
                              type Rdas-index;
                              description
                                "AS:nn (hex or decimal format)";
                            }
                          }  // list two-byte-as-or-four-byte-as
    
                          list ipv4-address {
                            when
                              "../format = 'ipv4-address'" {
                              description
                                "../Format = IPV4Address";
                            }
                            key "address addr-index";
                            description
                              "ipv4 address";
                            leaf address {
                              type inet:ipv4-address-no-zone;
                              description
                                "IPV4 address";
                            }
    
                            leaf addr-index {
                              type Rd-addr-index;
                              description
                                "Addr index";
                            }
                          }  // list ipv4-address
                        }  // list mp2mp-route-target
                      }  // container mp2mp-route-targets
    
                      container mp2mp-signaling-protocol {
                        description
                          "signaling protocol in this MP2MP";
                        container flow-label-load-balance {
                          description
                            "Enable Flow Label based load balancing";
                          leaf flow-label {
                            type Flow-label-load-balance;
                            description
                              "Flow Label load balance type";
                          }
    
                          leaf static {
                            type empty;
                            description
                              "Static Flow Label";
                          }
                        }  // container flow-label-load-balance
    
                        container ceids {
                          description
                            "Local Customer Edge Identifier Table";
                          list ceid {
                            key "ce-id";
                            description
                              "Local Customer Edge Identifier ";
                            container remote-ceid-attachment-circuits {
                              description
                                "AC And Remote Customer Edge Identifier
    Table";
                              list remote-ceid-attachment-circuit {
                                key "name remote-ce-id";
                                description
                                  "AC And Remote Customer Edge Identifier";
                                leaf name {
                                  type xr:Interface-name;
                                  description
                                    "The name of the Attachment Circuit";
                                }
    
                                leaf remote-ce-id {
                                  type Ce-id-range;
                                  description
                                    "Remote Customer Edge Identifier";
                                }
                              }  // list remote-ceid-attachment-circuit
                            }  // container remote-ceid-attachment-circuits
    
                            leaf evpn-vpws-seamless-integration {
                              type Evpnvpws-seamless-integration;
                              description
                                "Description for EVPN-VPWS Seamless
    Integration with Legacy VPWS";
                            }
    
                            leaf ce-id {
                              type Ce-id-range;
                              description
                                "Local Customer Edge Identifier";
                            }
                          }  // list ceid
                        }  // container ceids
    
                        leaf ce-range {
                          type Cedge-range;
                          description
                            "Local Customer Edge Identifier";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable signaling protocol";
                        }
                      }  // container mp2mp-signaling-protocol
    
                      leaf enable {
                        type empty;
                        description
                          "Enable auto-discovery";
                      }
                    }  // container mp2mp-auto-discovery
    
                    leaf mp2mpmtu {
                      type L2vpn-mtu-range;
                      units "byte";
                      description
                        "Maximum transmission unit for this MP2MP
    VPWS instance";
                    }
    
                    leaf mp2mp-control-word {
                      type empty;
                      description
                        "Disable control word";
                    }
    
                    leaf mp2mpl2-encapsulation {
                      type L2-encapsulation;
                      description
                        "Configure Layer 2 Encapsulation";
                    }
    
                    leaf mp2mp-interworking {
                      type Interworking;
                      description "Interworking";
                    }
    
                    leaf mp2mp-shutdown {
                      type empty;
                      description
                        "shutdown this MP2MP VPWS instance";
                    }
    
                    leaf mp2mpvpn-id {
                      type Vpnid-range;
                      description
                        "VPN Identifier";
                    }
    
                    leaf name {
                      type xr:Cisco-ios-xr-string {
                        length "1..26";
                      }
                      description
                        "Name of the multi point to multi point
    xconnect";
                    }
                  }  // list mp2mp-xconnect
                }  // container mp2mp-xconnects
    
                leaf name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Name of the xconnect group";
                }
              }  // list xconnect-group
            }  // container xconnect-groups
    
            container bridge-domain-groups {
              description
                "List of bridge groups";
              list bridge-domain-group {
                key "name";
                description "Bridge group";
                leaf name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Name of the Bridge group";
                }
    
                container bridge-domains {
                  description
                    "List of Bridge Domain";
                  list bridge-domain {
                    key "name";
                    description "bridge domain";
                    container bd-storm-controls {
                      description
                        "Storm Control";
                      list bd-storm-control {
                        must
                          "storm-control-unit";
                        key "sctype";
                        description
                          "Storm Control Type";
                        leaf sctype {
                          type Storm-control;
                          description
                            "Storm Control Type";
                        }
    
                        container storm-control-unit {
                          must
                            "kbits-per-sec or pkts-per-sec";
                          description
                            "Specify units for Storm Control Configuration";
                          leaf kbits-per-sec {
                            type Storm-control-kbps-range;
                            units "kbit/s";
                            description
                              "Kilobits Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                          }
    
                          leaf pkts-per-sec {
                            type Storm-control-pps-range;
                            units "packet/s";
                            description
                              "Packets Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                          }
                        }  // container storm-control-unit
                      }  // list bd-storm-control
                    }  // container bd-storm-controls
    
                    container member-vnis {
                      description
                        "Bridge Domain VxLAN Network Identifier Table";
                      list member-vni {
                        key "vni";
                        description
                          "Bridge Domain Member VxLAN Network Identifier";
                        container member-vni-static-mac-addresses {
                          description
                            "Static Mac Address Table";
                          list member-vni-static-mac-address {
                            key "mac-address";
                            description
                              "Static Mac Address Configuration";
                            leaf next-hop-ip {
                              type inet:ipv4-address-no-zone;
                              description
                                "Enable Static Mac Address Configuration";
                            }
    
                            leaf mac-address {
                              type yang:mac-address;
                              description
                                "Static MAC address";
                            }
                          }  // list member-vni-static-mac-address
                        }  // container member-vni-static-mac-addresses
    
                        leaf vni {
                          type uint32 {
                            range "1..16777215";
                          }
                          description
                            "VxLAN Network Identifier number";
                        }
                      }  // list member-vni
                    }  // container member-vnis
    
                    container bridge-domain-mac {
                      description
                        "MAC configuration commands";
                      container bd-mac-limit {
                        description
                          "MAC-Limit configuration commands";
                        leaf bd-mac-limit-action {
                          type Mac-limit-action;
                          description
                            "MAC address limit enforcement action";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable MAC-Limit configuration commands";
                        }
    
                        leaf bd-mac-limit-notif {
                          type Mac-notification;
                          description
                            "Mac Address Limit Notification";
                        }
    
                        leaf bd-mac-limit-max {
                          type Mac-limit-range;
                          description
                            "Number of MAC addresses after which MAC
    limit action is taken";
                        }
                      }  // container bd-mac-limit
    
                      container bd-mac-filters {
                        description
                          "Filter Mac Address";
                        list bd-mac-filter {
                          key "address";
                          description
                            "Static MAC address";
                          leaf drop {
                            type empty;
                            description
                              "MAC address for filtering";
                          }
    
                          leaf address {
                            type yang:mac-address;
                            description
                              "Static MAC address";
                          }
                        }  // list bd-mac-filter
                      }  // container bd-mac-filters
    
                      container mac-secure {
                        description "MAC Secure";
                        leaf logging {
                          type empty;
                          description
                            "MAC Secure Logging";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable MAC Secure";
                        }
    
                        leaf threshold {
                          type empty;
                          description
                            "MAC Secure Threshold";
                        }
    
                        leaf action {
                          type Mac-secure-action;
                          description
                            "MAC secure enforcement action";
                        }
    
                        leaf shutdown-recovery-timer {
                          type Mac-secure-shutdown-recovery-time-range;
                          description
                            "MAC Secure Shutdown Recovery Timer";
                        }
                      }  // container mac-secure
    
                      container bd-mac-aging {
                        description
                          "MAC-Aging configuration commands";
                        leaf bd-mac-aging-type {
                          type Mac-aging;
                          description
                            "MAC address aging type";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable MAC-Aging configuration commands";
                        }
    
                        leaf bd-mac-aging-time {
                          type Mac-aging-range;
                          description
                            "Mac Aging Time";
                        }
                      }  // container bd-mac-aging
    
                      leaf bd-mac-withdraw-relay {
                        type empty;
                        description
                          "Mac withdraw sent from access PW to access PW";
                      }
    
                      leaf bd-mac-withdraw-access-pw-disable {
                        type empty;
                        description
                          "MAC withdraw on Access PW";
                      }
    
                      leaf bd-mac-port-down-flush {
                        type empty;
                        description
                          "Disable MAC Flush when Port goes Down";
                      }
    
                      leaf bd-mac-withdraw {
                        type empty;
                        description
                          "Disable Mac Withdraw";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable MAC configuration commands";
                      }
    
                      leaf bd-mac-withdraw-behavior {
                        type Mac-withdraw-behavior;
                        description
                          "MAC withdraw sent on bridge port down";
                      }
    
                      leaf bd-mac-learn {
                        type Bdmac-learn;
                        description
                          "Mac Learning Type";
                      }
                    }  // container bridge-domain-mac
    
                    container nv-satellite {
                      description "nV Satellite";
                      leaf offload-ipv4-multicast-enable {
                        type empty;
                        description
                          "Enable IPv4 Multicast Offload to Satellite
    Nodes";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable nV Satellite Settings";
                      }
                    }  // container nv-satellite
    
                    container bridge-domain-pbb {
                      description
                        "Bridge Domain PBB";
                      container pbb-edges {
                        description "PBB Edge";
                        list pbb-edge {
                          key "isid core-bd-name";
                          description
                            "Configure BD as PBB Edge with ISID and
    associated PBB Core BD";
                          container pbb-edge-split-horizon-group {
                            description
                              "Split Horizon Group";
                            leaf disable {
                              type empty;
                              description
                                "Disable split horizon group";
                            }
                          }  // container pbb-edge-split-horizon-group
    
                          container pbb-static-mac-mappings {
                            description
                              "PBB Static Mac Address Mapping Table";
                            list pbb-static-mac-mapping {
                              key "address";
                              description
                                "PBB Static Mac Address Mapping
    Configuration";
                              leaf pbb-static-mac-mapping-bmac {
                                type yang:mac-address;
                                description
                                  "Static backbone MAC address to map with";
                              }
    
                              leaf address {
                                type yang:mac-address;
                                description
                                  "Static MAC address";
                              }
                            }  // list pbb-static-mac-mapping
                          }  // container pbb-static-mac-mappings
    
                          container pbb-edge-dhcp-profile {
                            description
                              "Attach a DHCP profile";
                            leaf profile-id {
                              type Interface-profile;
                              description
                                "Set the snooping profile";
                            }
    
                            leaf dhcp-snooping-id {
                              type string;
                              description
                                "Disable DHCP snooping";
                            }
                          }  // container pbb-edge-dhcp-profile
    
                          container pbb-edge-mac {
                            description
                              "MAC configuration commands";
                            container pbb-edge-mac-limit {
                              description
                                "MAC-Limit configuration commands";
                              leaf pbb-edge-mac-limit-action {
                                type Mac-limit-action;
                                description
                                  "MAC address limit enforcement action";
                              }
    
                              leaf enable {
                                type empty;
                                description
                                  "Enable MAC-Limit configuration commands";
                              }
    
                              leaf pbb-edge-mac-limit-max {
                                type Mac-limit-range;
                                description
                                  "Number of MAC addresses after which MAC
    limit action is taken";
                              }
    
                              leaf pbb-edge-mac-limit-notif {
                                type Mac-notification;
                                description
                                  "MAC address limit notification action";
                              }
                            }  // container pbb-edge-mac-limit
    
                            container pbb-edge-mac-aging {
                              description
                                "MAC-Aging configuration commands";
                              leaf pbb-edge-mac-aging-type {
                                type Mac-aging;
                                description
                                  "MAC address aging type";
                              }
    
                              leaf pbb-edge-mac-aging-time {
                                type Mac-aging-range;
                                description
                                  "Mac Aging Time";
                              }
    
                              leaf enable {
                                type empty;
                                description
                                  "Enable MAC-Aging configuration commands";
                              }
                            }  // container pbb-edge-mac-aging
    
                            container pbb-edge-mac-secure {
                              description
                                "MAC Secure";
                              leaf enable {
                                type empty;
                                description
                                  "Enable MAC Secure";
                              }
    
                              leaf accept-shutdown {
                                type empty;
                                description
                                  "Accept Virtual instance port to be
    shutdown on mac violation";
                              }
    
                              leaf logging {
                                type L2vpn-logging;
                                description
                                  "MAC Secure Logging";
                              }
    
                              leaf disable {
                                type empty;
                                description
                                  "Disable MAC Secure";
                              }
    
                              leaf action {
                                type Mac-secure-action;
                                description
                                  "MAC secure enforcement action";
                              }
                            }  // container pbb-edge-mac-secure
    
                            leaf pbb-edge-mac-learning {
                              type Mac-learn;
                              description
                                "Enable Mac Learning";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC configuration commands";
                            }
                          }  // container pbb-edge-mac
    
                          leaf pbb-edge-igmp-profile {
                            type xr:Cisco-ios-xr-string {
                              length "1..32";
                            }
                            description
                              "Attach a IGMP Snooping profile";
                          }
    
                          leaf unknown-unicast-bmac {
                            type yang:mac-address;
                            description
                              "Configure Unknown Unicast BMAC address for
    PBB Edge Port";
                          }
    
                          leaf isid {
                            type Pbbisid-range;
                            description "ISID";
                          }
    
                          leaf core-bd-name {
                            type xr:Cisco-ios-xr-string {
                              length "1..27";
                            }
                            description
                              "Core BD Name";
                          }
                        }  // list pbb-edge
                      }  // container pbb-edges
    
                      container pbb-core {
                        description "PBB Core";
                        container pbb-core-mac {
                          description
                            "MAC configuration commands";
                          container pbb-core-mac-aging {
                            description
                              "MAC-Aging configuration commands";
                            leaf pbb-core-mac-aging-type {
                              type Mac-aging;
                              description
                                "MAC address aging type";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Aging configuration commands";
                            }
    
                            leaf pbb-core-mac-aging-time {
                              type Mac-aging-range;
                              description
                                "Mac Aging Time";
                            }
                          }  // container pbb-core-mac-aging
    
                          container pbb-core-mac-limit {
                            description
                              "MAC-Limit configuration commands";
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Limit configuration commands";
                            }
    
                            leaf pbb-core-mac-limit-max {
                              type Mac-limit-range;
                              description
                                "Number of MAC addresses after which MAC
    limit action is taken";
                            }
    
                            leaf pbb-core-mac-limit-notif {
                              type Mac-notification;
                              description
                                "MAC address limit notification action";
                            }
    
                            leaf pbb-core-mac-limit-action {
                              type Mac-limit-action;
                              description
                                "MAC address limit enforcement action";
                            }
                          }  // container pbb-core-mac-limit
    
                          leaf pbb-core-mac-learning {
                            type Mac-learn;
                            description
                              "Enable Mac Learning";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable MAC configuration commands";
                          }
                        }  // container pbb-core-mac
    
                        container pbb-core-evis {
                          description
                            "PBB Core EVI Table";
                          list pbb-core-evi {
                            key "eviid";
                            description
                              "PBB Core EVI";
                            leaf eviid {
                              type Vpnid-range;
                              description
                                "Ethernet VPN ID";
                            }
                          }  // list pbb-core-evi
                        }  // container pbb-core-evis
    
                        container pbb-core-dhcp-profile {
                          description
                            "Attach a DHCP profile";
                          leaf profile-id {
                            type Interface-profile;
                            description
                              "Set the snooping profile";
                          }
    
                          leaf dhcp-snooping-id {
                            type string;
                            description
                              "Disable DHCP snooping";
                          }
                        }  // container pbb-core-dhcp-profile
    
                        leaf pbb-core-mmrp-flood-optimization {
                          type empty;
                          description
                            "Enabling MMRP PBB-VPLS Flood Optimization";
                        }
    
                        leaf vlan-id {
                          type Pbbvid-range;
                          description
                            "VLAN ID to push";
                        }
    
                        leaf pbb-core-igmp-profile {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a IGMP Snooping profile";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable Bridge Domain PBB Core Configuration";
                        }
                      }  // container pbb-core
                    }  // container bridge-domain-pbb
    
                    container bridge-domain-evis {
                      description
                        "Bridge Domain EVI Table";
                      list bridge-domain-evi {
                        key "vpn-id";
                        description
                          "Bridge Domain MPLS EVPN";
                        leaf vpn-id {
                          type Evpnvpnid-range;
                          description
                            "MPLS Ethernet VPN-ID";
                        }
                      }  // list bridge-domain-evi
                    }  // container bridge-domain-evis
    
                    container access-vfis {
                      description
                        "Specify the access virtual forwarding
    interface name";
                      list access-vfi {
                        key "name";
                        description
                          "Name of the Acess Virtual Forwarding
    Interface";
                        container access-vfi-pseudowires {
                          description
                            "List of pseudowires";
                          list access-vfi-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Pseudowire configuration";
                            container access-vfi-pseudowire-static-mac-addresses {
                              description
                                "Static Mac Address Table";
                              list access-vfi-pseudowire-static-mac-address {
                                key "address";
                                description
                                  "Static Mac Address Configuration";
                                leaf address {
                                  type yang:mac-address;
                                  description
                                    "Static MAC address";
                                }
                              }  // list access-vfi-pseudowire-static-mac-address
                            }  // container access-vfi-pseudowire-static-mac-addresses
    
                            leaf access-vfi-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "Pseudowire class template name to use for
    this pseudowire";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list access-vfi-pseudowire
                        }  // container access-vfi-pseudowires
    
                        leaf access-vfi-shutdown {
                          type empty;
                          description
                            "shutdown the AccessVfi";
                        }
    
                        leaf name {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the AccessVirtual Forwarding
    Interface";
                        }
                      }  // list access-vfi
                    }  // container access-vfis
    
                    container bd-pseudowires {
                      description
                        "List of pseudowires";
                      list bd-pseudowire {
                        key "neighbor pseudowire-id";
                        description
                          "Pseudowire configuration";
                        container pseudowire-dai {
                          description
                            "Access Pseudowire Dynamic ARP Inspection";
                          container pseudowire-dai-address-validation {
                            description
                              "Address Validation";
                            leaf ipv4-verification {
                              type L2vpn-verification;
                              description
                                "IPv4 Verification";
                            }
    
                            leaf destination-mac-verification {
                              type L2vpn-verification;
                              description
                                "Destination MAC Verification";
                            }
    
                            leaf source-mac-verification {
                              type L2vpn-verification;
                              description
                                "Source MAC Verification";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable Address Validation";
                            }
                          }  // container pseudowire-dai-address-validation
    
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable Dynamic ARP Inspection";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable Access Pseudowire Dynamic ARP
    Inspection";
                          }
                        }  // container pseudowire-dai
    
                        container bdpw-storm-control-types {
                          description
                            "Storm Control";
                          list bdpw-storm-control-type {
                            must
                              "storm-control-unit";
                            key "sctype";
                            description
                              "Storm Control Type";
                            leaf sctype {
                              type Storm-control;
                              description
                                "Storm Control Type";
                            }
    
                            container storm-control-unit {
                              must
                                "kbits-per-sec or pkts-per-sec";
                              description
                                "Specify units for Storm Control Configuration";
                              leaf kbits-per-sec {
                                type Storm-control-kbps-range;
                                units "kbit/s";
                                description
                                  "Kilobits Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
    
                              leaf pkts-per-sec {
                                type Storm-control-pps-range;
                                units "packet/s";
                                description
                                  "Packets Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
                            }  // container storm-control-unit
                          }  // list bdpw-storm-control-type
                        }  // container bdpw-storm-control-types
    
                        container pseudowire-profile {
                          description
                            "Attach a DHCP profile";
                          leaf profile-id {
                            type Interface-profile;
                            description
                              "Set the snooping profile";
                          }
    
                          leaf dhcp-snooping-id {
                            type string;
                            description
                              "Disable DHCP snooping";
                          }
                        }  // container pseudowire-profile
    
                        container bd-pw-static-mac-addresses {
                          description
                            "Static Mac Address Table";
                          list bd-pw-static-mac-address {
                            key "address";
                            description
                              "Static Mac Address Configuration";
                            leaf address {
                              type yang:mac-address;
                              description
                                "Static MAC address";
                            }
                          }  // list bd-pw-static-mac-address
                        }  // container bd-pw-static-mac-addresses
    
                        container pseudowire-ip-source-guard {
                          description
                            "IP Source Guard";
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable Dynamic IP source guard";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable IP Source Guard";
                          }
                        }  // container pseudowire-ip-source-guard
    
                        container pseudowire-mac {
                          description
                            "Bridge-domain Pseudowire MAC configuration
    commands";
                          container pseudowire-mac-secure {
                            description
                              "MAC Secure";
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC Secure";
                            }
    
                            leaf logging {
                              type L2vpn-logging;
                              description
                                "MAC Secure Logging";
                            }
    
                            leaf disable {
                              type empty;
                              description
                                "Disable MAC Secure";
                            }
    
                            leaf action {
                              type Mac-secure-action;
                              description
                                "MAC secure enforcement action";
                            }
    
                            leaf shutdown-recovery-timer {
                              type Mac-secure-shutdown-recovery-time-range;
                              description
                                "MAC Secure Shutdown Recovery Timer";
                            }
                          }  // container pseudowire-mac-secure
    
                          container pseudowire-mac-aging {
                            description
                              "MAC-Aging configuration commands";
                            leaf pseudowire-mac-aging-type {
                              type Mac-aging;
                              description
                                "MAC address aging type";
                            }
    
                            leaf pseudowire-mac-aging-time {
                              type Mac-aging-range;
                              description
                                "MAC Aging Time";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Aging configuration commands";
                            }
                          }  // container pseudowire-mac-aging
    
                          container pseudowire-mac-limit {
                            description
                              "MAC-Limit configuration commands";
                            leaf pseudowire-mac-limit-action {
                              type Mac-limit-action;
                              description
                                "Bridge Access Pseudowire MAC address limit
    enforcement action";
                            }
    
                            leaf pseudowire-mac-limit-notif {
                              type Mac-notification;
                              description
                                "MAC address limit notification action in a
    Bridge Access Pseudowire";
                            }
    
                            leaf pseudowire-mac-limit-max {
                              type Mac-limit-range;
                              description
                                "Number of MAC addresses on a Bridge Access
    Pseudowire after which MAC limit action is
    taken";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Limit configuration commands";
                            }
                          }  // container pseudowire-mac-limit
    
                          leaf pseudowire-mac-port-down-flush {
                            type Port-down-flush;
                            description
                              "Enable/Disable MAC Flush When Port goes
    down";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Bridge-domain Pseudowire MAC configuration
    mode";
                          }
    
                          leaf pseudowire-mac-learning {
                            type Mac-learn;
                            description
                              "Enable MAC Learning";
                          }
                        }  // container pseudowire-mac
    
                        container bd-pw-split-horizon {
                          description
                            "Split Horizon";
                          container bd-pw-split-horizon-group {
                            description
                              "Split Horizon Group";
                            leaf enable {
                              type empty;
                              description
                                "Enable split horizon group";
                            }
                          }  // container bd-pw-split-horizon-group
                        }  // container bd-pw-split-horizon
    
                        container bd-pw-mpls-static-labels {
                          description
                            "MPLS static labels";
                          leaf local-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire local static label";
                          }
    
                          leaf remote-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire remote static label";
                          }
                        }  // container bd-pw-mpls-static-labels
    
                        container bridge-domain-backup-pseudowires {
                          description
                            "List of pseudowires";
                          list bridge-domain-backup-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Backup pseudowire configuration";
                            leaf bridge-domain-backup-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "PW class template name to use for this
    pseudowire";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list bridge-domain-backup-pseudowire
                        }  // container bridge-domain-backup-pseudowires
    
                        leaf pseudowire-mld-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a MLD Snooping profile";
                        }
    
                        leaf pseudowire-igmp-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a IGMP Snooping profile";
                        }
    
                        leaf pseudowire-flooding {
                          type Interface-traffic-flood;
                          description
                            "Bridge-domain Pseudowire flooding";
                        }
    
                        leaf bd-pw-class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "PW class template name to use for this
    pseudowire";
                        }
    
                        leaf pseudowire-flooding-unknown-unicast {
                          type Interface-traffic-flood;
                          description
                            "Bridge-domain Pseudowire flooding Unknown
    Unicast";
                        }
    
                        leaf neighbor {
                          type inet:ipv4-address-no-zone;
                          description
                            "Neighbor IP address";
                        }
    
                        leaf pseudowire-id {
                          type Pseudowire-id-range;
                          description
                            "Pseudowire ID";
                        }
                      }  // list bd-pseudowire
                    }  // container bd-pseudowires
    
                    container vfis {
                      description
                        "Specify the virtual forwarding interface name";
                      list vfi {
                        key "name";
                        description
                          "Name of the Virtual Forwarding Interface";
                        container multicast-p2mp {
                          description
                            "Enable Multicast P2MP in this VFI";
                          container transports {
                            description
                              "Multicast P2MP Transport";
                            list transport {
                              key "transport-name";
                              description
                                "Multicast P2MP Transport Type";
                              leaf attribute-set-name {
                                type xr:Cisco-ios-xr-string {
                                  length "1..64";
                                }
                                description
                                  "Multicast P2MP TE Attribute Set Name";
                              }
    
                              leaf transport-name {
                                type Multicast-p2mp-transport;
                                description
                                  "Transport Type";
                              }
                            }  // list transport
                          }  // container transports
    
                          container signalings {
                            description
                              "Multicast P2MP Signaling Type";
                            list signaling {
                              key "signaling-name";
                              description
                                "Multicast P2MP Signaling Type";
                              leaf signaling-name {
                                type Multicast-p2mp-signaling;
                                description
                                  "Signaling Type";
                              }
                            }  // list signaling
                          }  // container signalings
    
                          leaf enable {
                            type empty;
                            description
                              "Enable Autodiscovery P2MP";
                          }
                        }  // container multicast-p2mp
    
                        container vfi-pseudowires {
                          description
                            "List of pseudowires";
                          list vfi-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Pseudowire configuration";
                            container vfi-pw-dhcp-snoop {
                              description
                                "Attach a DHCP Snooping profile";
                              leaf profile-id {
                                type Interface-profile;
                                description
                                  "Set the snooping profile";
                              }
    
                              leaf dhcp-snooping-id {
                                type string;
                                description
                                  "Disable DHCP snooping";
                              }
                            }  // container vfi-pw-dhcp-snoop
    
                            container vfi-pw-mpls-static-labels {
                              description
                                "MPLS static labels";
                              leaf local-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire local static label";
                              }
    
                              leaf remote-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire remote static label";
                              }
                            }  // container vfi-pw-mpls-static-labels
    
                            container pseudowire-static-mac-addresses {
                              description
                                "Static Mac Address Table";
                              list pseudowire-static-mac-address {
                                key "address";
                                description
                                  "Static Mac Address Configuration";
                                leaf address {
                                  type yang:mac-address;
                                  description
                                    "Static MAC address";
                                }
                              }  // list pseudowire-static-mac-address
                            }  // container pseudowire-static-mac-addresses
    
                            leaf vfi-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "PW class template name to use for this
    pseudowire";
                            }
    
                            leaf vfi-pw-igmp-snoop {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "Attach a IGMP Snooping profile";
                            }
    
                            leaf vfi-pw-mld-snoop {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "Attach a MLD Snooping profile";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list vfi-pseudowire
                        }  // container vfi-pseudowires
    
                        container bgp-auto-discovery {
                          description
                            "Enable Autodiscovery BGP in this VFI";
                          container ldp-signaling-protocol {
                            description
                              "Signaling Protocol LDP in this VFI
    configuration";
                            container vpls-id {
                              description
                                "VPLS ID";
                              leaf type {
                                type Ldp-vpls-id;
                                description
                                  "VPLS-ID Type";
                              }
    
                              leaf as {
                                when
                                  "../type = 'two-byte-as'" {
                                  description
                                    "../Type = TwoByteAS";
                                }
                                type Vpls-id-as-range;
                                description
                                  "Two byte AS number";
                              }
    
                              leaf as-index {
                                when
                                  "../type = 'two-byte-as'" {
                                  description
                                    "../Type = TwoByteAS";
                                }
                                type Vpls-id-as-index;
                                description
                                  "AS index";
                              }
    
                              leaf address {
                                when
                                  "../type = 'ipv4-address'" {
                                  description
                                    "../Type = IPV4Address";
                                }
                                type inet:ipv4-address-no-zone;
                                description
                                  "IPV4 address";
                              }
    
                              leaf address-index {
                                when
                                  "../type = 'ipv4-address'" {
                                  description
                                    "../Type = IPV4Address";
                                }
                                type Vpls-id-addr-index;
                                description
                                  "Address index";
                              }
                            }  // container vpls-id
    
                            container flow-label-load-balance {
                              description
                                "Enable Flow Label based load balancing";
                              leaf flow-label {
                                type Flow-label-load-balance;
                                description
                                  "Flow Label load balance type";
                              }
    
                              leaf static {
                                type empty;
                                description
                                  "Static Flow Label";
                              }
                            }  // container flow-label-load-balance
    
                            leaf enable {
                              type empty;
                              description
                                "Enable LDP as Signaling Protocol.Deletion
    of this object also causes deletion of all
    objects under LDPSignalingProtocol.";
                            }
                          }  // container ldp-signaling-protocol
    
                          container bgp-route-policy {
                            description
                              "Route policy";
                            leaf export {
                              type string;
                              description
                                "Export route policy";
                            }
                          }  // container bgp-route-policy
    
                          container route-distinguisher {
                            description
                              "Route Distinguisher";
                            leaf type {
                              type Bgp-route-distinguisher;
                              description
                                "Router Distinguisher Type";
                            }
    
                            leaf as {
                              when
                                "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                                description
                                  "../Type = TwoByteAS or ../Type =
    FourByteAS";
                              }
                              type Rdas-range;
                              description
                                "Two byte or 4 byte AS number";
                            }
    
                            leaf as-index {
                              when
                                "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                                description
                                  "../Type = TwoByteAS or ../Type =
    FourByteAS";
                              }
                              type Rdas-index;
                              description
                                "AS:nn (hex or decimal format)";
                            }
    
                            leaf address {
                              when
                                "../type = 'ipv4-address'" {
                                description
                                  "../Type = IPV4Address";
                              }
                              type inet:ipv4-address-no-zone;
                              description
                                "IPV4 address";
                            }
    
                            leaf addr-index {
                              when
                                "../type = 'ipv4-address'" {
                                description
                                  "../Type = IPV4Address";
                              }
                              type Rd-addr-index;
                              description
                                "Addr index";
                            }
                          }  // container route-distinguisher
    
                          container bgp-signaling-protocol {
                            description
                              "Enable Signaling Protocol BGP in this VFI";
                            container flow-label-load-balance {
                              description
                                "Enable Flow Label based load balancing";
                              leaf flow-label {
                                type Flow-label-load-balance;
                                description
                                  "Flow Label load balance type";
                              }
    
                              leaf static {
                                type empty;
                                description
                                  "Static Flow Label";
                              }
                            }  // container flow-label-load-balance
    
                            leaf ve-range {
                              type Vedge-range;
                              description
                                "Local Virtual Edge Block Configurable
    Range";
                            }
    
                            leaf veid {
                              type Veid-range;
                              description
                                "Local Virtual Edge Identifier";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable BGP as Signaling Protocol";
                            }
                          }  // container bgp-signaling-protocol
    
                          container route-targets {
                            description
                              "Route Target";
                            list route-target {
                              must
                                "two-byte-as-or-four-byte-as or ipv4-address" {
                                description
                                  "TwoByteAS-or-FourbyteAS or IPV4Address
    must be present.";
                              }
                              key "role format";
                              description
                                "Name of the Route Target";
                              leaf role {
                                type Bgp-route-target-role;
                                description
                                  "Role of the router target type";
                              }
    
                              leaf format {
                                type Bgp-route-target-format;
                                description
                                  "Format of the route target";
                              }
    
                              list two-byte-as-or-four-byte-as {
                                when
                                  "../format = 'two-byte-as' or ../format = 'four-byte-as'" {
                                  description
                                    "../Format = TwoByteAS or ../Format =
    FourbyteAS";
                                }
                                key "as as-index";
                                description
                                  "two byte as or four byte as";
                                leaf as {
                                  type Rdas-range;
                                  description
                                    "Two byte or 4 byte AS number";
                                }
    
                                leaf as-index {
                                  type Rdas-index;
                                  description
                                    "AS:nn (hex or decimal format)";
                                }
                              }  // list two-byte-as-or-four-byte-as
    
                              list ipv4-address {
                                when
                                  "../format = 'ipv4-address'" {
                                  description
                                    "../Format = IPV4Address";
                                }
                                key "address addr-index";
                                description
                                  "ipv4 address";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "IPV4 address";
                                }
    
                                leaf addr-index {
                                  type Rd-addr-index;
                                  description
                                    "Addr index";
                                }
                              }  // list ipv4-address
                            }  // list route-target
                          }  // container route-targets
    
                          leaf table-policy {
                            type string;
                            description
                              "Table Policy for installation of forwarding
    data to L2FIB";
                          }
    
                          leaf ad-control-word {
                            type empty;
                            description
                              "Enable control-word for this VFI";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable Autodiscovery BGP";
                          }
                        }  // container bgp-auto-discovery
    
                        leaf vfi-shutdown {
                          type empty;
                          description
                            "Enabling Shutdown";
                        }
    
                        leaf vpnid {
                          type Vpnid-range;
                          description
                            "VPN Identifier";
                        }
    
                        leaf name {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the Virtual Forwarding Interface";
                        }
                      }  // list vfi
                    }  // container vfis
    
                    container bridge-domainvnis {
                      description
                        "Bridge Domain EVPN VxLAN Network Identifier
    Table";
                      list bridge-domainvni {
                        key "vpn-id";
                        description
                          "Bridge Domain VxLAN EVPN";
                        leaf vpn-id {
                          type uint32 {
                            range "1..16777215";
                          }
                          description
                            "VxLAN Ethernet VPN-ID";
                        }
                      }  // list bridge-domainvni
                    }  // container bridge-domainvnis
    
                    container bd-attachment-circuits {
                      description
                        "Attachment Circuit table";
                      list bd-attachment-circuit {
                        key "name";
                        description
                          "Name of the Attachment Circuit";
                        container interface-ip-source-guard {
                          description
                            "IP Source Guard";
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable L2 Interface Dynamic IP source
    guard";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable IP Source Guard";
                          }
                        }  // container interface-ip-source-guard
    
                        container interface-dai {
                          description
                            "L2 Interface Dynamic ARP Inspection";
                          container interface-dai-address-validation {
                            description
                              "Address Validation";
                            leaf ipv4-verification {
                              type L2vpn-verification;
                              description
                                "IPv4 Verification";
                            }
    
                            leaf destination-mac-verification {
                              type L2vpn-verification;
                              description
                                "Destination MAC Verification";
                            }
    
                            leaf source-mac-verification {
                              type L2vpn-verification;
                              description
                                "Source MAC Verification";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable Address Validation";
                            }
                          }  // container interface-dai-address-validation
    
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable L2 Interface Dynamic ARP Inspection";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable L2 Interface Dynamic ARP Inspection";
                          }
                        }  // container interface-dai
    
                        container interface-profile {
                          description
                            "Attach a DHCP profile";
                          leaf profile-id {
                            type Interface-profile;
                            description
                              "Set the snooping profile";
                          }
    
                          leaf dhcp-snooping-id {
                            type string;
                            description
                              "Disable DHCP snooping";
                          }
                        }  // container interface-profile
    
                        container bdac-storm-control-types {
                          description
                            "Storm Control";
                          list bdac-storm-control-type {
                            must
                              "storm-control-unit";
                            key "sctype";
                            description
                              "Storm Control Type";
                            leaf sctype {
                              type Storm-control;
                              description
                                "Storm Control Type";
                            }
    
                            container storm-control-unit {
                              must
                                "kbits-per-sec or pkts-per-sec";
                              description
                                "Specify units for Storm Control Configuration";
                              leaf kbits-per-sec {
                                type Storm-control-kbps-range;
                                units "kbit/s";
                                description
                                  "Kilobits Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
    
                              leaf pkts-per-sec {
                                type Storm-control-pps-range;
                                units "packet/s";
                                description
                                  "Packets Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
                            }  // container storm-control-unit
                          }  // list bdac-storm-control-type
                        }  // container bdac-storm-control-types
    
                        container split-horizon {
                          description
                            "Split Horizon";
                          container split-horizon-group-id {
                            description
                              "Split Horizon Group ID";
                            leaf enable {
                              type empty;
                              description
                                "Enable split horizon group";
                            }
                          }  // container split-horizon-group-id
                        }  // container split-horizon
    
                        container static-mac-addresses {
                          description
                            "Static Mac Address Table";
                          list static-mac-address {
                            key "address";
                            description
                              "Static Mac Address Configuration";
                            leaf address {
                              type yang:mac-address;
                              description
                                "Static MAC address";
                            }
                          }  // list static-mac-address
                        }  // container static-mac-addresses
    
                        container interface-mac {
                          description
                            "MAC configuration commands";
                          container interface-mac-aging {
                            description
                              "MAC-Aging configuration commands";
                            leaf interface-mac-aging-time {
                              type Mac-aging-range;
                              description
                                "Mac Aging Time";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Aging configuration commands";
                            }
    
                            leaf interface-mac-aging-type {
                              type Mac-aging;
                              description
                                "MAC address aging type";
                            }
                          }  // container interface-mac-aging
    
                          container interface-mac-secure {
                            description
                              "MAC Secure";
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC Secure";
                            }
    
                            leaf logging {
                              type L2vpn-logging;
                              description
                                "MAC Secure Logging";
                            }
    
                            leaf disable {
                              type empty;
                              description
                                "Disable MAC Secure";
                            }
    
                            leaf action {
                              type Mac-secure-action;
                              description
                                "MAC secure enforcement action";
                            }
    
                            leaf shutdown-recovery-timer {
                              type Mac-secure-shutdown-recovery-time-range;
                              description
                                "MAC Secure Shutdown Recovery Timer";
                            }
                          }  // container interface-mac-secure
    
                          container interface-mac-limit {
                            description
                              "MAC-Limit configuration commands";
                            leaf interface-mac-limit-max {
                              type Mac-limit-range;
                              description
                                "Number of MAC addresses on an Interface
    after which MAC limit action is taken";
                            }
    
                            leaf interface-mac-limit-notif {
                              type Mac-notification;
                              description
                                "MAC address limit notification action in a
    Interface";
                            }
    
                            leaf interface-mac-limit-action {
                              type Mac-limit-action;
                              description
                                "Interface MAC address limit enforcement
    action";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Limit configuration commands";
                            }
                          }  // container interface-mac-limit
    
                          leaf interface-mac-port-down-flush {
                            type Port-down-flush;
                            description
                              "Enable/Disable MAC Flush When Port goes
    down";
                          }
    
                          leaf interface-mac-learning {
                            type Mac-learn;
                            description
                              "Enable Mac Learning";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable MAC configuration commands";
                          }
                        }  // container interface-mac
    
                        leaf interface-flooding {
                          type Interface-traffic-flood;
                          description
                            "Enable or Disable Flooding";
                        }
    
                        leaf interface-igmp-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a IGMP Snooping profile";
                        }
    
                        leaf interface-flooding-unknown-unicast {
                          type Interface-traffic-flood;
                          description
                            "Enable or Disable Unknown Unicast Flooding";
                        }
    
                        leaf interface-mld-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a MLD Snooping profile";
                        }
    
                        leaf name {
                          type xr:Interface-name;
                          description
                            "The name of the Attachment Circuit";
                        }
                      }  // list bd-attachment-circuit
                    }  // container bd-attachment-circuits
    
                    container bd-pseudowire-evpns {
                      description
                        "List of EVPN pseudowires";
                      list bd-pseudowire-evpn {
                        key "eviid acid";
                        description
                          "EVPN Pseudowire configuration";
                        leaf eviid {
                          type Evpnvpnid-range;
                          description
                            "Ethernet VPN ID";
                        }
    
                        leaf acid {
                          type Pseudowire-acid-range;
                          description "AC ID";
                        }
                      }  // list bd-pseudowire-evpn
                    }  // container bd-pseudowire-evpns
    
                    container ip-source-guard {
                      description
                        "IP Source Guard";
                      leaf logging {
                        type empty;
                        description
                          "Enable Logging";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable IP Source Guard";
                      }
                    }  // container ip-source-guard
    
                    container dai {
                      description
                        "Dynamic ARP Inspection";
                      container dai-address-validation {
                        description
                          "Address Validation";
                        leaf ipv4-verification {
                          type empty;
                          description
                            "Enable IPv4 Verification";
                        }
    
                        leaf destination-mac-verification {
                          type empty;
                          description
                            "Enable Destination MAC Verification";
                        }
    
                        leaf source-mac-verification {
                          type empty;
                          description
                            "Enable Source MAC Verification";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable Address Validation";
                        }
                      }  // container dai-address-validation
    
                      leaf logging {
                        type empty;
                        description
                          "Enable Logging";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable Dynamic ARP Inspection";
                      }
                    }  // container dai
    
                    container routed-interfaces {
                      description
                        "Bridge Domain Routed Interface Table";
                      list routed-interface {
                        key "interface-name";
                        description
                          "Bridge Domain Routed Interface";
                        container routed-interface-split-horizon-group {
                          description
                            "Routed interface split horizon group";
                          leaf routed-interface-split-horizon-group-core {
                            type empty;
                            description
                              "Configure BVI under SHG 1";
                          }
                        }  // container routed-interface-split-horizon-group
    
                        leaf interface-name {
                          type xr:Interface-name;
                          description
                            "The name of the Routed Interface";
                        }
                      }  // list routed-interface
                    }  // container routed-interfaces
    
                    leaf coupled-mode {
                      type empty;
                      description
                        "Coupled-mode configuration";
                    }
    
                    leaf shutdown {
                      type empty;
                      description
                        "shutdown the Bridge Domain";
                    }
    
                    leaf flooding-unknown-unicast {
                      type empty;
                      description
                        "Disable Unknown Unicast flooding";
                    }
    
                    leaf efp-visibility {
                      type empty;
                      description
                        "Enable multicast for multiple VLANs in the
    bridge of a BVI";
                    }
    
                    leaf l2-multicast-source {
                      type L2mc-src-traffic-enabled;
                      description
                        "L2MC Source Traffic Enabled";
                    }
    
                    leaf igmp-snooping-disable {
                      type empty;
                      description
                        "Disable IGMP Snooping";
                    }
    
                    leaf transport-mode {
                      type Bridge-domain-transport-mode;
                      description
                        "Bridge Domain Transport mode";
                    }
    
                    leaf mld-snooping {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Attach MLD Snooping Profile Name";
                    }
    
                    leaf bridge-domain-mtu {
                      type Bridge-bd-mtu-range;
                      units "byte";
                      description
                        "Maximum transmission unit for this Bridge
    Domain";
                    }
    
                    leaf dhcp {
                      type string {
                        length "1..32";
                      }
                      description
                        "DHCPv4 Snooping profile name";
                    }
    
                    leaf bridge-description {
                      type string {
                        length "1..64";
                      }
                      description
                        "Bridge-domain description Name";
                    }
    
                    leaf igmp-snooping {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Attach IGMP Snooping Profile Name";
                    }
    
                    leaf flooding {
                      type empty;
                      description
                        "Disable flooding";
                    }
    
                    leaf name {
                      type xr:Cisco-ios-xr-string {
                        length "1..27";
                      }
                      description
                        "Name of the bridge domain";
                    }
                  }  // list bridge-domain
                }  // container bridge-domains
              }  // list bridge-domain-group
            }  // container bridge-domain-groups
    
            container pseudowire-classes {
              description
                "List of pseudowire classes";
              list pseudowire-class {
                key "name";
                description "Pseudowire class";
                container l2tpv3-encapsulation {
                  description
                    "L2TPv3 encapsulation";
                  container sequencing {
                    description "Sequencing";
                    leaf sequencing {
                      type L2tpv3-sequencing;
                      default "off";
                      description "Sequencing";
                    }
    
                    leaf resync-threshold {
                      type Resync-threshold-range;
                      default "5";
                      description
                        "Out of sequence threshold";
                    }
                  }  // container sequencing
    
                  container type-of-service {
                    description
                      "Type of service";
                    leaf type-of-service-value {
                      type Type-of-service-range;
                      description
                        "Type of service value";
                    }
    
                    leaf type-of-service-mode {
                      type Type-of-service-mode;
                      description
                        "Type of service mode";
                    }
                  }  // container type-of-service
    
                  container signaling-protocol {
                    description
                      "L2TPv3 signaling protocol";
                    leaf protocol {
                      type L2tp-signaling-protocol;
                      default "l2tpv3";
                      description
                        "L2TPv3 signaling protocol";
                    }
    
                    leaf l2tpv3-class-name {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Name of the L2TPv3 class name";
                    }
                  }  // container signaling-protocol
    
                  container path-mtu {
                    description
                      "Path maximum transmission unit";
                    leaf enable {
                      type empty;
                      description
                        "Enable path MTU";
                    }
    
                    leaf max-path-mtu {
                      type Max-path-mtu-range;
                      description
                        "Maximum path maximum transmission unit";
                    }
                  }  // container path-mtu
    
                  leaf df-bit-set {
                    type empty;
                    description
                      "Set the do not fragment bit to 1";
                  }
    
                  leaf cookie-size {
                    type L2tp-cookie-size;
                    default "zero";
                    description "Cookie size";
                  }
    
                  leaf source-address {
                    type inet:ipv4-address-no-zone;
                    description
                      "Source IP address";
                  }
    
                  leaf transport-mode {
                    type Transport-mode;
                    description "Transport mode";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable L2TPv3 encapsulation";
                  }
    
                  leaf time-to-live {
                    type Time-to-live-range;
                    description "Time to live";
                  }
                }  // container l2tpv3-encapsulation
    
                container backup-disable-delay {
                  description
                    "Back Up Pseudowire class";
                  leaf type {
                    type Backup-disable;
                    description "Delay or Never";
                  }
    
                  leaf disable-backup {
                    when "../type = 'delay'" {
                      description
                        "../Type = Delay";
                    }
                    type Backup-disable-delay-range;
                    description
                      "Disable backup delay";
                  }
                }  // container backup-disable-delay
    
                container mpls-encapsulation {
                  description
                    "MPLS encapsulation";
                  container sequencing {
                    description "Sequencing";
                    leaf sequencing {
                      type Mpls-sequencing;
                      default "off";
                      description "Sequencing";
                    }
    
                    leaf resync-threshold {
                      type Resync-threshold-range;
                      default "5";
                      description
                        "Out of sequence threshold";
                    }
                  }  // container sequencing
    
                  container mpls-redundancy {
                    description
                      "Redundancy options for MPLS encapsulation";
                    leaf redundancy-one-way {
                      type empty;
                      description
                        "Force one-way PW redundancy behavior in
    Redundancy Group";
                    }
    
                    leaf redundancy-initial-delay {
                      type Pw-redundancy-initial-delay-range;
                      units "second";
                      description
                        "Initial delay before activating the
    redundant PW, in seconds";
                    }
                  }  // container mpls-redundancy
    
                  container preferred-path {
                    description "Preferred path";
                    leaf type {
                      type Preferred-path;
                      description
                        "Preferred Path Type";
                    }
    
                    leaf interface-tunnel-number {
                      when
                        "../type = 'te-tunnel' or ../type = 'ip-tunnel' or ../type = 'tp-tunnel'" {
                        description
                          "../Type = TE-Tunnel or ../Type =
    IP-Tunnel or ../Type = TP-Tunnel";
                      }
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Interface Tunnel number for preferred path";
                    }
    
                    leaf fallback-disable {
                      when
                        "../type = 'te-tunnel' or ../type = 'ip-tunnel' or ../type = 'tp-tunnel' or ../type = 'sr-te-policy' or ../type = 'named-te-tunnel'" {
                        description
                          "../Type = TE-Tunnel or ../Type =
    IP-Tunnel or ../Type = TP-Tunnel or .
    ./Type = SR-TE-Policy or ../Type =
    Named-TE-Tunnel";
                      }
                      type empty;
                      description
                        "Fallback disable";
                    }
    
                    leaf path-name {
                      when
                        "../type = 'sr-te-policy' or ../type = 'named-te-tunnel'" {
                        description
                          "../Type = SR-TE-Policy or ../Type =
    Named-TE-Tunnel";
                      }
                      type xr:Cisco-ios-xr-string {
                        length "1..60";
                      }
                      description
                        "Name of the SR TE Policy or IFName";
                    }
                  }  // container preferred-path
    
                  container load-balance-group {
                    description "Load Balancing";
                    container flow-label-load-balance {
                      description
                        "Enable Flow Label based load balancing";
                      leaf flow-label {
                        type Flow-label-load-balance;
                        description
                          "Flow Label load balance type";
                      }
    
                      leaf static {
                        type empty;
                        description
                          "Static Flow Label";
                      }
                    }  // container flow-label-load-balance
    
                    leaf flow-label-load-balance-code {
                      type Flow-label-tlv-code;
                      description
                        "Enable Legacy Flow Label TLV code";
                    }
    
                    leaf pw-label-load-balance {
                      type Load-balance;
                      description
                        "Enable PW Label based Load Balancing";
                    }
                  }  // container load-balance-group
    
                  leaf pw-switching-tlv {
                    type Pw-switching-point-tlv;
                    description
                      "Pseudowire Switching Point Tlv";
                  }
    
                  leaf static-tag-rewrite {
                    type Tag-rewrite-range;
                    description
                      "Static Tag rewrite";
                  }
    
                  leaf signaling-protocol {
                    type Mpls-signaling-protocol;
                    default "ldp";
                    description
                      "MPLS signaling protocol";
                  }
    
                  leaf vccv-type {
                    type Vccv-verification;
                    default "lsp-ping";
                    description
                      "VCCV verification type";
                  }
    
                  leaf source-address {
                    type inet:ipv4-address-no-zone;
                    description
                      "Source IP address";
                  }
    
                  leaf transport-mode {
                    type Transport-mode;
                    description "Transport mode";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable MPLS encapsulation";
                  }
    
                  leaf control-word {
                    type Control-word;
                    description
                      "Enable control word";
                  }
                }  // container mpls-encapsulation
    
                leaf mac-withdraw {
                  type empty;
                  description
                    "Enable backup MAC withdraw";
                }
    
                leaf enable {
                  type empty;
                  description
                    "Enable pseudowire class";
                }
    
                leaf name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Name of the pseudowire class";
                }
              }  // list pseudowire-class
            }  // container pseudowire-classes
    
            container vlan-switches {
              description
                "List of VLAN Switches";
              list vlan-switch {
                key "name";
                description "VLAN Switch";
                container vlan-switch-ports {
                  description
                    "List of VLAN Switched Ports";
                  list vlan-switch-port {
                    key "interface-name";
                    description
                      "VLAN Switched Port";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Interface name";
                    }
                  }  // list vlan-switch-port
                }  // container vlan-switch-ports
    
                container vni-ranges {
                  description
                    "Configure VLAN Switch VxLAN Ethernet VPN-ID
    ranges";
                  leaf vni-range1-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #1";
                  }
    
                  leaf vni-range1-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #1";
                  }
    
                  leaf vni-range2-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #2";
                  }
    
                  leaf vni-range2-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #2";
                  }
    
                  leaf vni-range3-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #3";
                  }
    
                  leaf vni-range3-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #3";
                  }
    
                  leaf vni-range4-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #4";
                  }
    
                  leaf vni-range4-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #4";
                  }
    
                  leaf vni-range5-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #5";
                  }
    
                  leaf vni-range5-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #5";
                  }
    
                  leaf vni-range6-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #6";
                  }
    
                  leaf vni-range6-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #6";
                  }
    
                  leaf vni-range7-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #7";
                  }
    
                  leaf vni-range7-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #7";
                  }
    
                  leaf vni-range8-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #8";
                  }
    
                  leaf vni-range8-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #8";
                  }
    
                  leaf vni-range9-min {
                    type uint32;
                    description
                      "Minimum value of VNI range #9";
                  }
    
                  leaf vni-range9-max {
                    type uint32;
                    description
                      "Maximum value of VNI range #9";
                  }
                }  // container vni-ranges
    
                container vlan-ranges {
                  description
                    "Configure VLAN Switch VLAN ranges";
                  leaf vlan-range1-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #1";
                  }
    
                  leaf vlan-range1-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #1";
                  }
    
                  leaf vlan-range2-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #2";
                  }
    
                  leaf vlan-range2-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #2";
                  }
    
                  leaf vlan-range3-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #3";
                  }
    
                  leaf vlan-range3-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #3";
                  }
    
                  leaf vlan-range4-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #4";
                  }
    
                  leaf vlan-range4-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #4";
                  }
    
                  leaf vlan-range5-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #5";
                  }
    
                  leaf vlan-range5-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #5";
                  }
    
                  leaf vlan-range6-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #6";
                  }
    
                  leaf vlan-range6-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #6";
                  }
    
                  leaf vlan-range7-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #7";
                  }
    
                  leaf vlan-range7-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #7";
                  }
    
                  leaf vlan-range8-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #8";
                  }
    
                  leaf vlan-range8-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #8";
                  }
    
                  leaf vlan-range9-min {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Minimum value of VLAN range #9";
                  }
    
                  leaf vlan-range9-max {
                    type L2vpn-vs-vlan-tag;
                    description
                      "Maximum value of VLAN range #9";
                  }
                }  // container vlan-ranges
    
                container routed-interface-ranges {
                  description
                    "Configure VLAN Switch Routed BVI Interface
    ranges";
                  leaf interface-range1-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #1";
                  }
    
                  leaf interface-range1-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #1";
                  }
    
                  leaf interface-range2-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #2";
                  }
    
                  leaf interface-range2-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #2";
                  }
    
                  leaf interface-range3-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #3";
                  }
    
                  leaf interface-range3-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #3";
                  }
    
                  leaf interface-range4-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #4";
                  }
    
                  leaf interface-range4-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #4";
                  }
    
                  leaf interface-range5-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #5";
                  }
    
                  leaf interface-range5-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #5";
                  }
    
                  leaf interface-range6-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #6";
                  }
    
                  leaf interface-range6-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #6";
                  }
    
                  leaf interface-range7-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #7";
                  }
    
                  leaf interface-range7-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #7";
                  }
    
                  leaf interface-range8-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #8";
                  }
    
                  leaf interface-range8-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #8";
                  }
    
                  leaf interface-range9-min {
                    type uint32;
                    description
                      "Minimum value of Interface range #9";
                  }
    
                  leaf interface-range9-max {
                    type uint32;
                    description
                      "Maximum value of Interface range #9";
                  }
                }  // container routed-interface-ranges
    
                leaf name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Name of the VLAN Switch";
                }
    
                container bridge-domains {
                  description
                    "List of Bridge Domain";
                  list bridge-domain {
                    key "name";
                    description "bridge domain";
                    container bd-storm-controls {
                      description
                        "Storm Control";
                      list bd-storm-control {
                        must
                          "storm-control-unit";
                        key "sctype";
                        description
                          "Storm Control Type";
                        leaf sctype {
                          type Storm-control;
                          description
                            "Storm Control Type";
                        }
    
                        container storm-control-unit {
                          must
                            "kbits-per-sec or pkts-per-sec";
                          description
                            "Specify units for Storm Control Configuration";
                          leaf kbits-per-sec {
                            type Storm-control-kbps-range;
                            units "kbit/s";
                            description
                              "Kilobits Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                          }
    
                          leaf pkts-per-sec {
                            type Storm-control-pps-range;
                            units "packet/s";
                            description
                              "Packets Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                          }
                        }  // container storm-control-unit
                      }  // list bd-storm-control
                    }  // container bd-storm-controls
    
                    container member-vnis {
                      description
                        "Bridge Domain VxLAN Network Identifier Table";
                      list member-vni {
                        key "vni";
                        description
                          "Bridge Domain Member VxLAN Network Identifier";
                        container member-vni-static-mac-addresses {
                          description
                            "Static Mac Address Table";
                          list member-vni-static-mac-address {
                            key "mac-address";
                            description
                              "Static Mac Address Configuration";
                            leaf next-hop-ip {
                              type inet:ipv4-address-no-zone;
                              description
                                "Enable Static Mac Address Configuration";
                            }
    
                            leaf mac-address {
                              type yang:mac-address;
                              description
                                "Static MAC address";
                            }
                          }  // list member-vni-static-mac-address
                        }  // container member-vni-static-mac-addresses
    
                        leaf vni {
                          type uint32 {
                            range "1..16777215";
                          }
                          description
                            "VxLAN Network Identifier number";
                        }
                      }  // list member-vni
                    }  // container member-vnis
    
                    container bridge-domain-mac {
                      description
                        "MAC configuration commands";
                      container bd-mac-limit {
                        description
                          "MAC-Limit configuration commands";
                        leaf bd-mac-limit-action {
                          type Mac-limit-action;
                          description
                            "MAC address limit enforcement action";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable MAC-Limit configuration commands";
                        }
    
                        leaf bd-mac-limit-notif {
                          type Mac-notification;
                          description
                            "Mac Address Limit Notification";
                        }
    
                        leaf bd-mac-limit-max {
                          type Mac-limit-range;
                          description
                            "Number of MAC addresses after which MAC
    limit action is taken";
                        }
                      }  // container bd-mac-limit
    
                      container bd-mac-filters {
                        description
                          "Filter Mac Address";
                        list bd-mac-filter {
                          key "address";
                          description
                            "Static MAC address";
                          leaf drop {
                            type empty;
                            description
                              "MAC address for filtering";
                          }
    
                          leaf address {
                            type yang:mac-address;
                            description
                              "Static MAC address";
                          }
                        }  // list bd-mac-filter
                      }  // container bd-mac-filters
    
                      container mac-secure {
                        description "MAC Secure";
                        leaf logging {
                          type empty;
                          description
                            "MAC Secure Logging";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable MAC Secure";
                        }
    
                        leaf threshold {
                          type empty;
                          description
                            "MAC Secure Threshold";
                        }
    
                        leaf action {
                          type Mac-secure-action;
                          description
                            "MAC secure enforcement action";
                        }
    
                        leaf shutdown-recovery-timer {
                          type Mac-secure-shutdown-recovery-time-range;
                          description
                            "MAC Secure Shutdown Recovery Timer";
                        }
                      }  // container mac-secure
    
                      container bd-mac-aging {
                        description
                          "MAC-Aging configuration commands";
                        leaf bd-mac-aging-type {
                          type Mac-aging;
                          description
                            "MAC address aging type";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable MAC-Aging configuration commands";
                        }
    
                        leaf bd-mac-aging-time {
                          type Mac-aging-range;
                          description
                            "Mac Aging Time";
                        }
                      }  // container bd-mac-aging
    
                      leaf bd-mac-withdraw-relay {
                        type empty;
                        description
                          "Mac withdraw sent from access PW to access PW";
                      }
    
                      leaf bd-mac-withdraw-access-pw-disable {
                        type empty;
                        description
                          "MAC withdraw on Access PW";
                      }
    
                      leaf bd-mac-port-down-flush {
                        type empty;
                        description
                          "Disable MAC Flush when Port goes Down";
                      }
    
                      leaf bd-mac-withdraw {
                        type empty;
                        description
                          "Disable Mac Withdraw";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable MAC configuration commands";
                      }
    
                      leaf bd-mac-withdraw-behavior {
                        type Mac-withdraw-behavior;
                        description
                          "MAC withdraw sent on bridge port down";
                      }
    
                      leaf bd-mac-learn {
                        type Bdmac-learn;
                        description
                          "Mac Learning Type";
                      }
                    }  // container bridge-domain-mac
    
                    container nv-satellite {
                      description "nV Satellite";
                      leaf offload-ipv4-multicast-enable {
                        type empty;
                        description
                          "Enable IPv4 Multicast Offload to Satellite
    Nodes";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable nV Satellite Settings";
                      }
                    }  // container nv-satellite
    
                    container bridge-domain-pbb {
                      description
                        "Bridge Domain PBB";
                      container pbb-edges {
                        description "PBB Edge";
                        list pbb-edge {
                          key "isid core-bd-name";
                          description
                            "Configure BD as PBB Edge with ISID and
    associated PBB Core BD";
                          container pbb-edge-split-horizon-group {
                            description
                              "Split Horizon Group";
                            leaf disable {
                              type empty;
                              description
                                "Disable split horizon group";
                            }
                          }  // container pbb-edge-split-horizon-group
    
                          container pbb-static-mac-mappings {
                            description
                              "PBB Static Mac Address Mapping Table";
                            list pbb-static-mac-mapping {
                              key "address";
                              description
                                "PBB Static Mac Address Mapping
    Configuration";
                              leaf pbb-static-mac-mapping-bmac {
                                type yang:mac-address;
                                description
                                  "Static backbone MAC address to map with";
                              }
    
                              leaf address {
                                type yang:mac-address;
                                description
                                  "Static MAC address";
                              }
                            }  // list pbb-static-mac-mapping
                          }  // container pbb-static-mac-mappings
    
                          container pbb-edge-dhcp-profile {
                            description
                              "Attach a DHCP profile";
                            leaf profile-id {
                              type Interface-profile;
                              description
                                "Set the snooping profile";
                            }
    
                            leaf dhcp-snooping-id {
                              type string;
                              description
                                "Disable DHCP snooping";
                            }
                          }  // container pbb-edge-dhcp-profile
    
                          container pbb-edge-mac {
                            description
                              "MAC configuration commands";
                            container pbb-edge-mac-limit {
                              description
                                "MAC-Limit configuration commands";
                              leaf pbb-edge-mac-limit-action {
                                type Mac-limit-action;
                                description
                                  "MAC address limit enforcement action";
                              }
    
                              leaf enable {
                                type empty;
                                description
                                  "Enable MAC-Limit configuration commands";
                              }
    
                              leaf pbb-edge-mac-limit-max {
                                type Mac-limit-range;
                                description
                                  "Number of MAC addresses after which MAC
    limit action is taken";
                              }
    
                              leaf pbb-edge-mac-limit-notif {
                                type Mac-notification;
                                description
                                  "MAC address limit notification action";
                              }
                            }  // container pbb-edge-mac-limit
    
                            container pbb-edge-mac-aging {
                              description
                                "MAC-Aging configuration commands";
                              leaf pbb-edge-mac-aging-type {
                                type Mac-aging;
                                description
                                  "MAC address aging type";
                              }
    
                              leaf pbb-edge-mac-aging-time {
                                type Mac-aging-range;
                                description
                                  "Mac Aging Time";
                              }
    
                              leaf enable {
                                type empty;
                                description
                                  "Enable MAC-Aging configuration commands";
                              }
                            }  // container pbb-edge-mac-aging
    
                            container pbb-edge-mac-secure {
                              description
                                "MAC Secure";
                              leaf enable {
                                type empty;
                                description
                                  "Enable MAC Secure";
                              }
    
                              leaf accept-shutdown {
                                type empty;
                                description
                                  "Accept Virtual instance port to be
    shutdown on mac violation";
                              }
    
                              leaf logging {
                                type L2vpn-logging;
                                description
                                  "MAC Secure Logging";
                              }
    
                              leaf disable {
                                type empty;
                                description
                                  "Disable MAC Secure";
                              }
    
                              leaf action {
                                type Mac-secure-action;
                                description
                                  "MAC secure enforcement action";
                              }
                            }  // container pbb-edge-mac-secure
    
                            leaf pbb-edge-mac-learning {
                              type Mac-learn;
                              description
                                "Enable Mac Learning";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC configuration commands";
                            }
                          }  // container pbb-edge-mac
    
                          leaf pbb-edge-igmp-profile {
                            type xr:Cisco-ios-xr-string {
                              length "1..32";
                            }
                            description
                              "Attach a IGMP Snooping profile";
                          }
    
                          leaf unknown-unicast-bmac {
                            type yang:mac-address;
                            description
                              "Configure Unknown Unicast BMAC address for
    PBB Edge Port";
                          }
    
                          leaf isid {
                            type Pbbisid-range;
                            description "ISID";
                          }
    
                          leaf core-bd-name {
                            type xr:Cisco-ios-xr-string {
                              length "1..27";
                            }
                            description
                              "Core BD Name";
                          }
                        }  // list pbb-edge
                      }  // container pbb-edges
    
                      container pbb-core {
                        description "PBB Core";
                        container pbb-core-mac {
                          description
                            "MAC configuration commands";
                          container pbb-core-mac-aging {
                            description
                              "MAC-Aging configuration commands";
                            leaf pbb-core-mac-aging-type {
                              type Mac-aging;
                              description
                                "MAC address aging type";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Aging configuration commands";
                            }
    
                            leaf pbb-core-mac-aging-time {
                              type Mac-aging-range;
                              description
                                "Mac Aging Time";
                            }
                          }  // container pbb-core-mac-aging
    
                          container pbb-core-mac-limit {
                            description
                              "MAC-Limit configuration commands";
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Limit configuration commands";
                            }
    
                            leaf pbb-core-mac-limit-max {
                              type Mac-limit-range;
                              description
                                "Number of MAC addresses after which MAC
    limit action is taken";
                            }
    
                            leaf pbb-core-mac-limit-notif {
                              type Mac-notification;
                              description
                                "MAC address limit notification action";
                            }
    
                            leaf pbb-core-mac-limit-action {
                              type Mac-limit-action;
                              description
                                "MAC address limit enforcement action";
                            }
                          }  // container pbb-core-mac-limit
    
                          leaf pbb-core-mac-learning {
                            type Mac-learn;
                            description
                              "Enable Mac Learning";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable MAC configuration commands";
                          }
                        }  // container pbb-core-mac
    
                        container pbb-core-evis {
                          description
                            "PBB Core EVI Table";
                          list pbb-core-evi {
                            key "eviid";
                            description
                              "PBB Core EVI";
                            leaf eviid {
                              type Vpnid-range;
                              description
                                "Ethernet VPN ID";
                            }
                          }  // list pbb-core-evi
                        }  // container pbb-core-evis
    
                        container pbb-core-dhcp-profile {
                          description
                            "Attach a DHCP profile";
                          leaf profile-id {
                            type Interface-profile;
                            description
                              "Set the snooping profile";
                          }
    
                          leaf dhcp-snooping-id {
                            type string;
                            description
                              "Disable DHCP snooping";
                          }
                        }  // container pbb-core-dhcp-profile
    
                        leaf pbb-core-mmrp-flood-optimization {
                          type empty;
                          description
                            "Enabling MMRP PBB-VPLS Flood Optimization";
                        }
    
                        leaf vlan-id {
                          type Pbbvid-range;
                          description
                            "VLAN ID to push";
                        }
    
                        leaf pbb-core-igmp-profile {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a IGMP Snooping profile";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable Bridge Domain PBB Core Configuration";
                        }
                      }  // container pbb-core
                    }  // container bridge-domain-pbb
    
                    container bridge-domain-evis {
                      description
                        "Bridge Domain EVI Table";
                      list bridge-domain-evi {
                        key "vpn-id";
                        description
                          "Bridge Domain MPLS EVPN";
                        leaf vpn-id {
                          type Evpnvpnid-range;
                          description
                            "MPLS Ethernet VPN-ID";
                        }
                      }  // list bridge-domain-evi
                    }  // container bridge-domain-evis
    
                    container access-vfis {
                      description
                        "Specify the access virtual forwarding
    interface name";
                      list access-vfi {
                        key "name";
                        description
                          "Name of the Acess Virtual Forwarding
    Interface";
                        container access-vfi-pseudowires {
                          description
                            "List of pseudowires";
                          list access-vfi-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Pseudowire configuration";
                            container access-vfi-pseudowire-static-mac-addresses {
                              description
                                "Static Mac Address Table";
                              list access-vfi-pseudowire-static-mac-address {
                                key "address";
                                description
                                  "Static Mac Address Configuration";
                                leaf address {
                                  type yang:mac-address;
                                  description
                                    "Static MAC address";
                                }
                              }  // list access-vfi-pseudowire-static-mac-address
                            }  // container access-vfi-pseudowire-static-mac-addresses
    
                            leaf access-vfi-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "Pseudowire class template name to use for
    this pseudowire";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list access-vfi-pseudowire
                        }  // container access-vfi-pseudowires
    
                        leaf access-vfi-shutdown {
                          type empty;
                          description
                            "shutdown the AccessVfi";
                        }
    
                        leaf name {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the AccessVirtual Forwarding
    Interface";
                        }
                      }  // list access-vfi
                    }  // container access-vfis
    
                    container bd-pseudowires {
                      description
                        "List of pseudowires";
                      list bd-pseudowire {
                        key "neighbor pseudowire-id";
                        description
                          "Pseudowire configuration";
                        container pseudowire-dai {
                          description
                            "Access Pseudowire Dynamic ARP Inspection";
                          container pseudowire-dai-address-validation {
                            description
                              "Address Validation";
                            leaf ipv4-verification {
                              type L2vpn-verification;
                              description
                                "IPv4 Verification";
                            }
    
                            leaf destination-mac-verification {
                              type L2vpn-verification;
                              description
                                "Destination MAC Verification";
                            }
    
                            leaf source-mac-verification {
                              type L2vpn-verification;
                              description
                                "Source MAC Verification";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable Address Validation";
                            }
                          }  // container pseudowire-dai-address-validation
    
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable Dynamic ARP Inspection";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable Access Pseudowire Dynamic ARP
    Inspection";
                          }
                        }  // container pseudowire-dai
    
                        container bdpw-storm-control-types {
                          description
                            "Storm Control";
                          list bdpw-storm-control-type {
                            must
                              "storm-control-unit";
                            key "sctype";
                            description
                              "Storm Control Type";
                            leaf sctype {
                              type Storm-control;
                              description
                                "Storm Control Type";
                            }
    
                            container storm-control-unit {
                              must
                                "kbits-per-sec or pkts-per-sec";
                              description
                                "Specify units for Storm Control Configuration";
                              leaf kbits-per-sec {
                                type Storm-control-kbps-range;
                                units "kbit/s";
                                description
                                  "Kilobits Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
    
                              leaf pkts-per-sec {
                                type Storm-control-pps-range;
                                units "packet/s";
                                description
                                  "Packets Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
                            }  // container storm-control-unit
                          }  // list bdpw-storm-control-type
                        }  // container bdpw-storm-control-types
    
                        container pseudowire-profile {
                          description
                            "Attach a DHCP profile";
                          leaf profile-id {
                            type Interface-profile;
                            description
                              "Set the snooping profile";
                          }
    
                          leaf dhcp-snooping-id {
                            type string;
                            description
                              "Disable DHCP snooping";
                          }
                        }  // container pseudowire-profile
    
                        container bd-pw-static-mac-addresses {
                          description
                            "Static Mac Address Table";
                          list bd-pw-static-mac-address {
                            key "address";
                            description
                              "Static Mac Address Configuration";
                            leaf address {
                              type yang:mac-address;
                              description
                                "Static MAC address";
                            }
                          }  // list bd-pw-static-mac-address
                        }  // container bd-pw-static-mac-addresses
    
                        container pseudowire-ip-source-guard {
                          description
                            "IP Source Guard";
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable Dynamic IP source guard";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable IP Source Guard";
                          }
                        }  // container pseudowire-ip-source-guard
    
                        container pseudowire-mac {
                          description
                            "Bridge-domain Pseudowire MAC configuration
    commands";
                          container pseudowire-mac-secure {
                            description
                              "MAC Secure";
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC Secure";
                            }
    
                            leaf logging {
                              type L2vpn-logging;
                              description
                                "MAC Secure Logging";
                            }
    
                            leaf disable {
                              type empty;
                              description
                                "Disable MAC Secure";
                            }
    
                            leaf action {
                              type Mac-secure-action;
                              description
                                "MAC secure enforcement action";
                            }
    
                            leaf shutdown-recovery-timer {
                              type Mac-secure-shutdown-recovery-time-range;
                              description
                                "MAC Secure Shutdown Recovery Timer";
                            }
                          }  // container pseudowire-mac-secure
    
                          container pseudowire-mac-aging {
                            description
                              "MAC-Aging configuration commands";
                            leaf pseudowire-mac-aging-type {
                              type Mac-aging;
                              description
                                "MAC address aging type";
                            }
    
                            leaf pseudowire-mac-aging-time {
                              type Mac-aging-range;
                              description
                                "MAC Aging Time";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Aging configuration commands";
                            }
                          }  // container pseudowire-mac-aging
    
                          container pseudowire-mac-limit {
                            description
                              "MAC-Limit configuration commands";
                            leaf pseudowire-mac-limit-action {
                              type Mac-limit-action;
                              description
                                "Bridge Access Pseudowire MAC address limit
    enforcement action";
                            }
    
                            leaf pseudowire-mac-limit-notif {
                              type Mac-notification;
                              description
                                "MAC address limit notification action in a
    Bridge Access Pseudowire";
                            }
    
                            leaf pseudowire-mac-limit-max {
                              type Mac-limit-range;
                              description
                                "Number of MAC addresses on a Bridge Access
    Pseudowire after which MAC limit action is
    taken";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Limit configuration commands";
                            }
                          }  // container pseudowire-mac-limit
    
                          leaf pseudowire-mac-port-down-flush {
                            type Port-down-flush;
                            description
                              "Enable/Disable MAC Flush When Port goes
    down";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Bridge-domain Pseudowire MAC configuration
    mode";
                          }
    
                          leaf pseudowire-mac-learning {
                            type Mac-learn;
                            description
                              "Enable MAC Learning";
                          }
                        }  // container pseudowire-mac
    
                        container bd-pw-split-horizon {
                          description
                            "Split Horizon";
                          container bd-pw-split-horizon-group {
                            description
                              "Split Horizon Group";
                            leaf enable {
                              type empty;
                              description
                                "Enable split horizon group";
                            }
                          }  // container bd-pw-split-horizon-group
                        }  // container bd-pw-split-horizon
    
                        container bd-pw-mpls-static-labels {
                          description
                            "MPLS static labels";
                          leaf local-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire local static label";
                          }
    
                          leaf remote-static-label {
                            type Pseudowire-label-range;
                            description
                              "Pseudowire remote static label";
                          }
                        }  // container bd-pw-mpls-static-labels
    
                        container bridge-domain-backup-pseudowires {
                          description
                            "List of pseudowires";
                          list bridge-domain-backup-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Backup pseudowire configuration";
                            leaf bridge-domain-backup-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "PW class template name to use for this
    pseudowire";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list bridge-domain-backup-pseudowire
                        }  // container bridge-domain-backup-pseudowires
    
                        leaf pseudowire-mld-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a MLD Snooping profile";
                        }
    
                        leaf pseudowire-igmp-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a IGMP Snooping profile";
                        }
    
                        leaf pseudowire-flooding {
                          type Interface-traffic-flood;
                          description
                            "Bridge-domain Pseudowire flooding";
                        }
    
                        leaf bd-pw-class {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "PW class template name to use for this
    pseudowire";
                        }
    
                        leaf pseudowire-flooding-unknown-unicast {
                          type Interface-traffic-flood;
                          description
                            "Bridge-domain Pseudowire flooding Unknown
    Unicast";
                        }
    
                        leaf neighbor {
                          type inet:ipv4-address-no-zone;
                          description
                            "Neighbor IP address";
                        }
    
                        leaf pseudowire-id {
                          type Pseudowire-id-range;
                          description
                            "Pseudowire ID";
                        }
                      }  // list bd-pseudowire
                    }  // container bd-pseudowires
    
                    container vfis {
                      description
                        "Specify the virtual forwarding interface name";
                      list vfi {
                        key "name";
                        description
                          "Name of the Virtual Forwarding Interface";
                        container multicast-p2mp {
                          description
                            "Enable Multicast P2MP in this VFI";
                          container transports {
                            description
                              "Multicast P2MP Transport";
                            list transport {
                              key "transport-name";
                              description
                                "Multicast P2MP Transport Type";
                              leaf attribute-set-name {
                                type xr:Cisco-ios-xr-string {
                                  length "1..64";
                                }
                                description
                                  "Multicast P2MP TE Attribute Set Name";
                              }
    
                              leaf transport-name {
                                type Multicast-p2mp-transport;
                                description
                                  "Transport Type";
                              }
                            }  // list transport
                          }  // container transports
    
                          container signalings {
                            description
                              "Multicast P2MP Signaling Type";
                            list signaling {
                              key "signaling-name";
                              description
                                "Multicast P2MP Signaling Type";
                              leaf signaling-name {
                                type Multicast-p2mp-signaling;
                                description
                                  "Signaling Type";
                              }
                            }  // list signaling
                          }  // container signalings
    
                          leaf enable {
                            type empty;
                            description
                              "Enable Autodiscovery P2MP";
                          }
                        }  // container multicast-p2mp
    
                        container vfi-pseudowires {
                          description
                            "List of pseudowires";
                          list vfi-pseudowire {
                            key "neighbor pseudowire-id";
                            description
                              "Pseudowire configuration";
                            container vfi-pw-dhcp-snoop {
                              description
                                "Attach a DHCP Snooping profile";
                              leaf profile-id {
                                type Interface-profile;
                                description
                                  "Set the snooping profile";
                              }
    
                              leaf dhcp-snooping-id {
                                type string;
                                description
                                  "Disable DHCP snooping";
                              }
                            }  // container vfi-pw-dhcp-snoop
    
                            container vfi-pw-mpls-static-labels {
                              description
                                "MPLS static labels";
                              leaf local-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire local static label";
                              }
    
                              leaf remote-static-label {
                                type Pseudowire-label-range;
                                description
                                  "Pseudowire remote static label";
                              }
                            }  // container vfi-pw-mpls-static-labels
    
                            container pseudowire-static-mac-addresses {
                              description
                                "Static Mac Address Table";
                              list pseudowire-static-mac-address {
                                key "address";
                                description
                                  "Static Mac Address Configuration";
                                leaf address {
                                  type yang:mac-address;
                                  description
                                    "Static MAC address";
                                }
                              }  // list pseudowire-static-mac-address
                            }  // container pseudowire-static-mac-addresses
    
                            leaf vfi-pw-class {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "PW class template name to use for this
    pseudowire";
                            }
    
                            leaf vfi-pw-igmp-snoop {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "Attach a IGMP Snooping profile";
                            }
    
                            leaf vfi-pw-mld-snoop {
                              type xr:Cisco-ios-xr-string {
                                length "1..32";
                              }
                              description
                                "Attach a MLD Snooping profile";
                            }
    
                            leaf neighbor {
                              type inet:ipv4-address-no-zone;
                              description
                                "Neighbor IP address";
                            }
    
                            leaf pseudowire-id {
                              type Pseudowire-id-range;
                              description
                                "Pseudowire ID";
                            }
                          }  // list vfi-pseudowire
                        }  // container vfi-pseudowires
    
                        container bgp-auto-discovery {
                          description
                            "Enable Autodiscovery BGP in this VFI";
                          container ldp-signaling-protocol {
                            description
                              "Signaling Protocol LDP in this VFI
    configuration";
                            container vpls-id {
                              description
                                "VPLS ID";
                              leaf type {
                                type Ldp-vpls-id;
                                description
                                  "VPLS-ID Type";
                              }
    
                              leaf as {
                                when
                                  "../type = 'two-byte-as'" {
                                  description
                                    "../Type = TwoByteAS";
                                }
                                type Vpls-id-as-range;
                                description
                                  "Two byte AS number";
                              }
    
                              leaf as-index {
                                when
                                  "../type = 'two-byte-as'" {
                                  description
                                    "../Type = TwoByteAS";
                                }
                                type Vpls-id-as-index;
                                description
                                  "AS index";
                              }
    
                              leaf address {
                                when
                                  "../type = 'ipv4-address'" {
                                  description
                                    "../Type = IPV4Address";
                                }
                                type inet:ipv4-address-no-zone;
                                description
                                  "IPV4 address";
                              }
    
                              leaf address-index {
                                when
                                  "../type = 'ipv4-address'" {
                                  description
                                    "../Type = IPV4Address";
                                }
                                type Vpls-id-addr-index;
                                description
                                  "Address index";
                              }
                            }  // container vpls-id
    
                            container flow-label-load-balance {
                              description
                                "Enable Flow Label based load balancing";
                              leaf flow-label {
                                type Flow-label-load-balance;
                                description
                                  "Flow Label load balance type";
                              }
    
                              leaf static {
                                type empty;
                                description
                                  "Static Flow Label";
                              }
                            }  // container flow-label-load-balance
    
                            leaf enable {
                              type empty;
                              description
                                "Enable LDP as Signaling Protocol.Deletion
    of this object also causes deletion of all
    objects under LDPSignalingProtocol.";
                            }
                          }  // container ldp-signaling-protocol
    
                          container bgp-route-policy {
                            description
                              "Route policy";
                            leaf export {
                              type string;
                              description
                                "Export route policy";
                            }
                          }  // container bgp-route-policy
    
                          container route-distinguisher {
                            description
                              "Route Distinguisher";
                            leaf type {
                              type Bgp-route-distinguisher;
                              description
                                "Router Distinguisher Type";
                            }
    
                            leaf as {
                              when
                                "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                                description
                                  "../Type = TwoByteAS or ../Type =
    FourByteAS";
                              }
                              type Rdas-range;
                              description
                                "Two byte or 4 byte AS number";
                            }
    
                            leaf as-index {
                              when
                                "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                                description
                                  "../Type = TwoByteAS or ../Type =
    FourByteAS";
                              }
                              type Rdas-index;
                              description
                                "AS:nn (hex or decimal format)";
                            }
    
                            leaf address {
                              when
                                "../type = 'ipv4-address'" {
                                description
                                  "../Type = IPV4Address";
                              }
                              type inet:ipv4-address-no-zone;
                              description
                                "IPV4 address";
                            }
    
                            leaf addr-index {
                              when
                                "../type = 'ipv4-address'" {
                                description
                                  "../Type = IPV4Address";
                              }
                              type Rd-addr-index;
                              description
                                "Addr index";
                            }
                          }  // container route-distinguisher
    
                          container bgp-signaling-protocol {
                            description
                              "Enable Signaling Protocol BGP in this VFI";
                            container flow-label-load-balance {
                              description
                                "Enable Flow Label based load balancing";
                              leaf flow-label {
                                type Flow-label-load-balance;
                                description
                                  "Flow Label load balance type";
                              }
    
                              leaf static {
                                type empty;
                                description
                                  "Static Flow Label";
                              }
                            }  // container flow-label-load-balance
    
                            leaf ve-range {
                              type Vedge-range;
                              description
                                "Local Virtual Edge Block Configurable
    Range";
                            }
    
                            leaf veid {
                              type Veid-range;
                              description
                                "Local Virtual Edge Identifier";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable BGP as Signaling Protocol";
                            }
                          }  // container bgp-signaling-protocol
    
                          container route-targets {
                            description
                              "Route Target";
                            list route-target {
                              must
                                "two-byte-as-or-four-byte-as or ipv4-address" {
                                description
                                  "TwoByteAS-or-FourbyteAS or IPV4Address
    must be present.";
                              }
                              key "role format";
                              description
                                "Name of the Route Target";
                              leaf role {
                                type Bgp-route-target-role;
                                description
                                  "Role of the router target type";
                              }
    
                              leaf format {
                                type Bgp-route-target-format;
                                description
                                  "Format of the route target";
                              }
    
                              list two-byte-as-or-four-byte-as {
                                when
                                  "../format = 'two-byte-as' or ../format = 'four-byte-as'" {
                                  description
                                    "../Format = TwoByteAS or ../Format =
    FourbyteAS";
                                }
                                key "as as-index";
                                description
                                  "two byte as or four byte as";
                                leaf as {
                                  type Rdas-range;
                                  description
                                    "Two byte or 4 byte AS number";
                                }
    
                                leaf as-index {
                                  type Rdas-index;
                                  description
                                    "AS:nn (hex or decimal format)";
                                }
                              }  // list two-byte-as-or-four-byte-as
    
                              list ipv4-address {
                                when
                                  "../format = 'ipv4-address'" {
                                  description
                                    "../Format = IPV4Address";
                                }
                                key "address addr-index";
                                description
                                  "ipv4 address";
                                leaf address {
                                  type inet:ipv4-address-no-zone;
                                  description
                                    "IPV4 address";
                                }
    
                                leaf addr-index {
                                  type Rd-addr-index;
                                  description
                                    "Addr index";
                                }
                              }  // list ipv4-address
                            }  // list route-target
                          }  // container route-targets
    
                          leaf table-policy {
                            type string;
                            description
                              "Table Policy for installation of forwarding
    data to L2FIB";
                          }
    
                          leaf ad-control-word {
                            type empty;
                            description
                              "Enable control-word for this VFI";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable Autodiscovery BGP";
                          }
                        }  // container bgp-auto-discovery
    
                        leaf vfi-shutdown {
                          type empty;
                          description
                            "Enabling Shutdown";
                        }
    
                        leaf vpnid {
                          type Vpnid-range;
                          description
                            "VPN Identifier";
                        }
    
                        leaf name {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Name of the Virtual Forwarding Interface";
                        }
                      }  // list vfi
                    }  // container vfis
    
                    container bridge-domainvnis {
                      description
                        "Bridge Domain EVPN VxLAN Network Identifier
    Table";
                      list bridge-domainvni {
                        key "vpn-id";
                        description
                          "Bridge Domain VxLAN EVPN";
                        leaf vpn-id {
                          type uint32 {
                            range "1..16777215";
                          }
                          description
                            "VxLAN Ethernet VPN-ID";
                        }
                      }  // list bridge-domainvni
                    }  // container bridge-domainvnis
    
                    container bd-attachment-circuits {
                      description
                        "Attachment Circuit table";
                      list bd-attachment-circuit {
                        key "name";
                        description
                          "Name of the Attachment Circuit";
                        container interface-ip-source-guard {
                          description
                            "IP Source Guard";
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable L2 Interface Dynamic IP source
    guard";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable IP Source Guard";
                          }
                        }  // container interface-ip-source-guard
    
                        container interface-dai {
                          description
                            "L2 Interface Dynamic ARP Inspection";
                          container interface-dai-address-validation {
                            description
                              "Address Validation";
                            leaf ipv4-verification {
                              type L2vpn-verification;
                              description
                                "IPv4 Verification";
                            }
    
                            leaf destination-mac-verification {
                              type L2vpn-verification;
                              description
                                "Destination MAC Verification";
                            }
    
                            leaf source-mac-verification {
                              type L2vpn-verification;
                              description
                                "Source MAC Verification";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable Address Validation";
                            }
                          }  // container interface-dai-address-validation
    
                          leaf logging {
                            type L2vpn-logging;
                            description
                              "Logging Type";
                          }
    
                          leaf disable {
                            type empty;
                            description
                              "Disable L2 Interface Dynamic ARP Inspection";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable L2 Interface Dynamic ARP Inspection";
                          }
                        }  // container interface-dai
    
                        container interface-profile {
                          description
                            "Attach a DHCP profile";
                          leaf profile-id {
                            type Interface-profile;
                            description
                              "Set the snooping profile";
                          }
    
                          leaf dhcp-snooping-id {
                            type string;
                            description
                              "Disable DHCP snooping";
                          }
                        }  // container interface-profile
    
                        container bdac-storm-control-types {
                          description
                            "Storm Control";
                          list bdac-storm-control-type {
                            must
                              "storm-control-unit";
                            key "sctype";
                            description
                              "Storm Control Type";
                            leaf sctype {
                              type Storm-control;
                              description
                                "Storm Control Type";
                            }
    
                            container storm-control-unit {
                              must
                                "kbits-per-sec or pkts-per-sec";
                              description
                                "Specify units for Storm Control Configuration";
                              leaf kbits-per-sec {
                                type Storm-control-kbps-range;
                                units "kbit/s";
                                description
                                  "Kilobits Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
    
                              leaf pkts-per-sec {
                                type Storm-control-pps-range;
                                units "packet/s";
                                description
                                  "Packets Per Second, PktsPerSec and KbitsPerSec
    cannot be configured together";
                              }
                            }  // container storm-control-unit
                          }  // list bdac-storm-control-type
                        }  // container bdac-storm-control-types
    
                        container split-horizon {
                          description
                            "Split Horizon";
                          container split-horizon-group-id {
                            description
                              "Split Horizon Group ID";
                            leaf enable {
                              type empty;
                              description
                                "Enable split horizon group";
                            }
                          }  // container split-horizon-group-id
                        }  // container split-horizon
    
                        container static-mac-addresses {
                          description
                            "Static Mac Address Table";
                          list static-mac-address {
                            key "address";
                            description
                              "Static Mac Address Configuration";
                            leaf address {
                              type yang:mac-address;
                              description
                                "Static MAC address";
                            }
                          }  // list static-mac-address
                        }  // container static-mac-addresses
    
                        container interface-mac {
                          description
                            "MAC configuration commands";
                          container interface-mac-aging {
                            description
                              "MAC-Aging configuration commands";
                            leaf interface-mac-aging-time {
                              type Mac-aging-range;
                              description
                                "Mac Aging Time";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Aging configuration commands";
                            }
    
                            leaf interface-mac-aging-type {
                              type Mac-aging;
                              description
                                "MAC address aging type";
                            }
                          }  // container interface-mac-aging
    
                          container interface-mac-secure {
                            description
                              "MAC Secure";
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC Secure";
                            }
    
                            leaf logging {
                              type L2vpn-logging;
                              description
                                "MAC Secure Logging";
                            }
    
                            leaf disable {
                              type empty;
                              description
                                "Disable MAC Secure";
                            }
    
                            leaf action {
                              type Mac-secure-action;
                              description
                                "MAC secure enforcement action";
                            }
    
                            leaf shutdown-recovery-timer {
                              type Mac-secure-shutdown-recovery-time-range;
                              description
                                "MAC Secure Shutdown Recovery Timer";
                            }
                          }  // container interface-mac-secure
    
                          container interface-mac-limit {
                            description
                              "MAC-Limit configuration commands";
                            leaf interface-mac-limit-max {
                              type Mac-limit-range;
                              description
                                "Number of MAC addresses on an Interface
    after which MAC limit action is taken";
                            }
    
                            leaf interface-mac-limit-notif {
                              type Mac-notification;
                              description
                                "MAC address limit notification action in a
    Interface";
                            }
    
                            leaf interface-mac-limit-action {
                              type Mac-limit-action;
                              description
                                "Interface MAC address limit enforcement
    action";
                            }
    
                            leaf enable {
                              type empty;
                              description
                                "Enable MAC-Limit configuration commands";
                            }
                          }  // container interface-mac-limit
    
                          leaf interface-mac-port-down-flush {
                            type Port-down-flush;
                            description
                              "Enable/Disable MAC Flush When Port goes
    down";
                          }
    
                          leaf interface-mac-learning {
                            type Mac-learn;
                            description
                              "Enable Mac Learning";
                          }
    
                          leaf enable {
                            type empty;
                            description
                              "Enable MAC configuration commands";
                          }
                        }  // container interface-mac
    
                        leaf interface-flooding {
                          type Interface-traffic-flood;
                          description
                            "Enable or Disable Flooding";
                        }
    
                        leaf interface-igmp-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a IGMP Snooping profile";
                        }
    
                        leaf interface-flooding-unknown-unicast {
                          type Interface-traffic-flood;
                          description
                            "Enable or Disable Unknown Unicast Flooding";
                        }
    
                        leaf interface-mld-snoop {
                          type xr:Cisco-ios-xr-string {
                            length "1..32";
                          }
                          description
                            "Attach a MLD Snooping profile";
                        }
    
                        leaf name {
                          type xr:Interface-name;
                          description
                            "The name of the Attachment Circuit";
                        }
                      }  // list bd-attachment-circuit
                    }  // container bd-attachment-circuits
    
                    container bd-pseudowire-evpns {
                      description
                        "List of EVPN pseudowires";
                      list bd-pseudowire-evpn {
                        key "eviid acid";
                        description
                          "EVPN Pseudowire configuration";
                        leaf eviid {
                          type Evpnvpnid-range;
                          description
                            "Ethernet VPN ID";
                        }
    
                        leaf acid {
                          type Pseudowire-acid-range;
                          description "AC ID";
                        }
                      }  // list bd-pseudowire-evpn
                    }  // container bd-pseudowire-evpns
    
                    container ip-source-guard {
                      description
                        "IP Source Guard";
                      leaf logging {
                        type empty;
                        description
                          "Enable Logging";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable IP Source Guard";
                      }
                    }  // container ip-source-guard
    
                    container dai {
                      description
                        "Dynamic ARP Inspection";
                      container dai-address-validation {
                        description
                          "Address Validation";
                        leaf ipv4-verification {
                          type empty;
                          description
                            "Enable IPv4 Verification";
                        }
    
                        leaf destination-mac-verification {
                          type empty;
                          description
                            "Enable Destination MAC Verification";
                        }
    
                        leaf source-mac-verification {
                          type empty;
                          description
                            "Enable Source MAC Verification";
                        }
    
                        leaf enable {
                          type empty;
                          description
                            "Enable Address Validation";
                        }
                      }  // container dai-address-validation
    
                      leaf logging {
                        type empty;
                        description
                          "Enable Logging";
                      }
    
                      leaf enable {
                        type empty;
                        description
                          "Enable Dynamic ARP Inspection";
                      }
                    }  // container dai
    
                    container routed-interfaces {
                      description
                        "Bridge Domain Routed Interface Table";
                      list routed-interface {
                        key "interface-name";
                        description
                          "Bridge Domain Routed Interface";
                        container routed-interface-split-horizon-group {
                          description
                            "Routed interface split horizon group";
                          leaf routed-interface-split-horizon-group-core {
                            type empty;
                            description
                              "Configure BVI under SHG 1";
                          }
                        }  // container routed-interface-split-horizon-group
    
                        leaf interface-name {
                          type xr:Interface-name;
                          description
                            "The name of the Routed Interface";
                        }
                      }  // list routed-interface
                    }  // container routed-interfaces
    
                    leaf coupled-mode {
                      type empty;
                      description
                        "Coupled-mode configuration";
                    }
    
                    leaf shutdown {
                      type empty;
                      description
                        "shutdown the Bridge Domain";
                    }
    
                    leaf flooding-unknown-unicast {
                      type empty;
                      description
                        "Disable Unknown Unicast flooding";
                    }
    
                    leaf efp-visibility {
                      type empty;
                      description
                        "Enable multicast for multiple VLANs in the
    bridge of a BVI";
                    }
    
                    leaf l2-multicast-source {
                      type L2mc-src-traffic-enabled;
                      description
                        "L2MC Source Traffic Enabled";
                    }
    
                    leaf igmp-snooping-disable {
                      type empty;
                      description
                        "Disable IGMP Snooping";
                    }
    
                    leaf transport-mode {
                      type Bridge-domain-transport-mode;
                      description
                        "Bridge Domain Transport mode";
                    }
    
                    leaf mld-snooping {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Attach MLD Snooping Profile Name";
                    }
    
                    leaf bridge-domain-mtu {
                      type Bridge-bd-mtu-range;
                      units "byte";
                      description
                        "Maximum transmission unit for this Bridge
    Domain";
                    }
    
                    leaf dhcp {
                      type string {
                        length "1..32";
                      }
                      description
                        "DHCPv4 Snooping profile name";
                    }
    
                    leaf bridge-description {
                      type string {
                        length "1..64";
                      }
                      description
                        "Bridge-domain description Name";
                    }
    
                    leaf igmp-snooping {
                      type xr:Cisco-ios-xr-string {
                        length "1..32";
                      }
                      description
                        "Attach IGMP Snooping Profile Name";
                    }
    
                    leaf flooding {
                      type empty;
                      description
                        "Disable flooding";
                    }
    
                    leaf name {
                      type xr:Cisco-ios-xr-string {
                        length "1..27";
                      }
                      description
                        "Name of the bridge domain";
                    }
                  }  // list bridge-domain
                }  // container bridge-domains
              }  // list vlan-switch
            }  // container vlan-switches
    
            container flexible-xconnect-service-table {
              description
                "List of Flexible XConnect Services";
              container vlan-unaware-flexible-xconnect-services {
                description
                  "List of Vlan-Unaware Flexible XConnect
    Services";
                list vlan-unaware-flexible-xconnect-service {
                  key "name";
                  description
                    "Flexible XConnect Service";
                  container vlan-unaware-fxc-attachment-circuits {
                    description
                      "List of attachment circuits";
                    list vlan-unaware-fxc-attachment-circuit {
                      key "name";
                      description
                        "Attachment circuit interface";
                      leaf name {
                        type xr:Interface-name;
                        description
                          "Name of the attachment circuit interface";
                      }
                    }  // list vlan-unaware-fxc-attachment-circuit
                  }  // container vlan-unaware-fxc-attachment-circuits
    
                  container vlan-unaware-fxc-pseudowire-evpns {
                    description
                      "List of EVPN Services";
                    list vlan-unaware-fxc-pseudowire-evpn {
                      key "eviid acid";
                      description
                        "EVPN FXC Service Configuration";
                      leaf eviid {
                        type Evpnvpnid-range;
                        description
                          "Ethernet VPN ID";
                      }
    
                      leaf acid {
                        type Pseudowire-acid-range;
                        description "AC ID";
                      }
                    }  // list vlan-unaware-fxc-pseudowire-evpn
                  }  // container vlan-unaware-fxc-pseudowire-evpns
    
                  leaf name {
                    type xr:Cisco-ios-xr-string {
                      length "1..23";
                    }
                    description
                      "Name of the Flexible XConnect Service";
                  }
                }  // list vlan-unaware-flexible-xconnect-service
              }  // container vlan-unaware-flexible-xconnect-services
    
              container vlan-aware-flexible-xconnect-services {
                description
                  "List of Vlan-Aware Flexible XConnect Services";
                list vlan-aware-flexible-xconnect-service {
                  key "eviid";
                  description
                    "Flexible XConnect Service";
                  container vlan-aware-fxc-attachment-circuits {
                    description
                      "List of attachment circuits";
                    list vlan-aware-fxc-attachment-circuit {
                      key "name";
                      description
                        "Attachment circuit interface";
                      leaf name {
                        type xr:Interface-name;
                        description
                          "Name of the attachment circuit interface";
                      }
                    }  // list vlan-aware-fxc-attachment-circuit
                  }  // container vlan-aware-fxc-attachment-circuits
    
                  leaf eviid {
                    type Evpnvpnid-range;
                    description
                      "Ethernet VPN ID";
                  }
                }  // list vlan-aware-flexible-xconnect-service
              }  // container vlan-aware-flexible-xconnect-services
            }  // container flexible-xconnect-service-table
    
            container redundancy {
              description "Redundancy groups";
              container iccp-redundancy-groups {
                description
                  "List of Inter-Chassis Communication Protocol
    redundancy groups";
                list iccp-redundancy-group {
                  key "group-id";
                  description
                    "ICCP Redundancy group";
                  container iccp-interfaces {
                    description
                      "List of interfaces";
                    list iccp-interface {
                      key "interface-name";
                      description
                        "Interface name";
                      leaf secondary-vlan-range {
                        type string;
                        description
                          "Secondary VLAN range, in the form of 1-3,5
    ,8-11";
                      }
    
                      leaf recovery-delay {
                        type uint32 {
                          range "30..3600";
                        }
                        default "180";
                        description
                          "Failure clear recovery delay";
                      }
    
                      leaf primary-vlan-range {
                        type string;
                        description
                          "Primary VLAN range, in the form of 1-3,5
    ,8-11";
                      }
    
                      leaf mac-flush-tcn {
                        type empty;
                        description
                          "Enable STP-TCN MAC flushing";
                      }
    
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface name";
                      }
                    }  // list iccp-interface
                  }  // container iccp-interfaces
    
                  leaf multi-homing-node-id {
                    type uint32 {
                      range "0..254";
                    }
                    description
                      "ICCP-based service multi-homing node ID";
                  }
    
                  leaf group-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description "Group ID";
                  }
                }  // list iccp-redundancy-group
              }  // container iccp-redundancy-groups
    
              leaf enable {
                type empty;
                description
                  "Enable redundancy groups";
              }
            }  // container redundancy
          }  // container database
    
          container pbb {
            description "L2VPN PBB Global";
            leaf backbone-source-mac {
              type yang:mac-address;
              description "Backbone Source MAC";
            }
          }  // container pbb
    
          container auto-discovery {
            description
              "Global auto-discovery attributes";
            container bgp-signaling {
              description
                "Global bgp signaling attributes";
              leaf mtu-mismatch-ignore {
                type empty;
                description
                  "Ignore MTU mismatch for auto-discovered
    pseudowires";
              }
            }  // container bgp-signaling
          }  // container auto-discovery
    
          container utility {
            description "L2VPN utilities";
            container logging {
              description
                "L2VPN logging utility";
              leaf bridge-domain-state-change {
                type empty;
                description
                  "Enable Bridge Domain state change logging";
              }
    
              leaf pseudowire-state-change {
                type empty;
                description
                  "Enable pseudowire state change logging";
              }
    
              leaf vfi {
                type empty;
                description
                  "Enable VFI state change logging";
              }
    
              leaf nsr-state-change {
                type empty;
                description
                  "Enable Non Stop Routing state change logging";
              }
    
              leaf pwhe-replication-state-change {
                type empty;
                description
                  "Enable PW-HE Replication state change logging";
              }
            }  // container logging
          }  // container utility
    
          container snmp {
            description
              "SNMP related configuration";
            container mib {
              description
                "MIB related configuration";
              container mib-interface {
                description
                  "Interface related configuration for MIB";
                container format {
                  description
                    "MIB interface name output format";
                  leaf external-interface-format {
                    type empty;
                    description
                      "Set MIB interface name output in slash
    format (/)";
                  }
                }  // container format
              }  // container mib-interface
    
              container mib-pseudowire {
                description
                  "Pseudowire related configuration for MIB";
                leaf statistics {
                  type empty;
                  description
                    "Enable pseudowire statistics in MIB output";
                }
              }  // container mib-pseudowire
            }  // container mib
          }  // container snmp
    
          leaf mtu-mismatch-ignore {
            type empty;
            description
              "Ignore MTU Mismatch for XCs";
          }
    
          leaf tcn-propagation {
            type empty;
            description
              "Topology change notification propagation";
          }
    
          leaf pwoam-refresh {
            type uint32 {
              range "1..4095";
            }
            units "second";
            description
              "Configure PW OAM refresh interval";
          }
    
          leaf load-balance {
            type Load-balance;
            description
              "Enable flow load balancing on l2vpn bridges";
          }
    
          leaf mspw-description {
            type string {
              length "1..64";
            }
            description
              "MS-PW global description";
          }
    
          leaf mac-limit-threshold {
            type Mac-limit-threshold-range;
            units "percentage";
            description
              "Configure MAC limit threshold percent";
          }
    
          leaf pw-status-disable {
            type empty;
            description "Disable PW status";
          }
    
          leaf enable {
            type empty;
            description "Enable L2VPN feature";
          }
    
          leaf pw-grouping {
            type empty;
            description "Enable PW grouping";
          }
    
          leaf capability {
            type L2vpn-capability-mode;
            description "L2VPN Capability Mode";
          }
    
          leaf l2vpn-router-id {
            type inet:ipv4-address-no-zone;
            description "Global L2VPN Router ID";
          }
        }  // container l2vpn
    
        container generic-interface-lists {
          description
            "Generic Interface List configuration";
          list generic-interface-list {
            key "generic-interface-list-name";
            description "Generic interface list";
            container interfaces {
              description "Interface table";
              list interface {
                key "interface-name";
                description "Interface";
                leaf enable {
                  type empty;
                  description "Enable interface";
                }
    
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Name of the interface";
                }
              }  // list interface
            }  // container interfaces
    
            leaf enable {
              type empty;
              description
                "Enable interface list";
            }
    
            leaf generic-interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Name of the interface list";
            }
          }  // list generic-interface-list
        }  // container generic-interface-lists
    
        container evpn {
          description "EVPN configuration";
          container evpn-tables {
            description "EVPN submodes";
            container evpn-timers {
              description
                "Enter EVPN timers configuration submode";
              leaf evpn-carving {
                type uint32 {
                  range "0..300";
                }
                default "0";
                description
                  "Global Carving timer";
              }
    
              leaf evpn-mac-postpone {
                type uint32 {
                  range "0..300";
                }
                default "300";
                description
                  "Global MAC postpone timer";
              }
    
              leaf evpn-ac-debounce {
                type uint32 {
                  range "0..300000";
                }
                default "3000";
                description
                  "Global AC Debounce timer";
              }
    
              leaf evpn-backup-replacement-delay {
                type uint32 {
                  range "0..300000";
                }
                units "millisecond";
                default "6000";
                description
                  "Global Backup Replacement Delay (milliseconds)
    timer";
              }
    
              leaf evpn-recovery {
                type uint32 {
                  range "0..3600";
                }
                default "30";
                description
                  "Global Recovery timer";
              }
    
              leaf enable {
                type empty;
                description "Enable EVPN timers";
              }
    
              leaf evpn-peering {
                type uint32 {
                  range "0..300";
                }
                default "3";
                description
                  "Global Peering timer";
              }
            }  // container evpn-timers
    
            container evpn-virtual-access-vfis {
              description
                "Virtual Access VFI interfaces";
              list evpn-virtual-access-vfi {
                key "name";
                description "Virtual Access VFI";
                container evpn-virtual-access-vfi-timers {
                  description
                    "Enter Virtual Forwarding Interface timers
    configuration submode";
                  leaf evpn-virtual-access-vfiac-debounce {
                    type uint32 {
                      range "0..300000";
                    }
                    default "3000";
                    description
                      "Virtual Forwarding Interface-specific AC
    Debounce timer";
                  }
    
                  leaf evpn-virtual-access-vfi-recovery {
                    type uint32 {
                      range "0..3600";
                    }
                    default "30";
                    description
                      "Virtual Forwarding Interface-specific
    Recovery timer";
                  }
    
                  leaf evpn-virtual-access-vfi-peering {
                    type uint32 {
                      range "0..300";
                    }
                    default "3";
                    description
                      "Virtual Forwarding Interface-specific
    Peering timer";
                  }
    
                  leaf evpn-virtual-access-vfi-carving {
                    type uint32 {
                      range "0..300";
                    }
                    default "0";
                    description
                      "Virtual Forwarding Interface-specific
    Carving timer";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Virtual Forwarding Interface timers";
                  }
                }  // container evpn-virtual-access-vfi-timers
    
                leaf name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Name of the Virtual Access VFI";
                }
    
                container evpn-virtual-ethernet-segment {
                  description
                    "Enter Ethernet Segment configuration submode";
                  leaf enable {
                    type empty;
                    description
                      "Enable Ethernet Segment";
                  }
    
                  leaf service-carving-mcast-type {
                    type Ethernet-segment-service-carving-mcast;
                    description
                      "Ethernet-Segment Service Carving multicast mode";
                  }
    
                  leaf es-import-route-target {
                    type yang:mac-address;
                    description
                      "ES-Import Route Target";
                  }
    
                  leaf service-carving-type {
                    type Ethernet-segment-service-carving;
                    description
                      "Ethernet-Segment Service Carving mode";
                  }
    
                  container identifier {
                    presence
                      "Indicates a identifier node is configured.";
                    description
                      "Ethernet segment identifier";
                    leaf bytes01 {
                      type xr:Hex-integer;
                      mandatory true;
                      description
                        "Type 0's 1st Byte or Type Byte and 1st Byte";
                    }
    
                    leaf bytes23 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "2nd and 3rd Bytes";
                    }
    
                    leaf bytes45 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "4th and 5th Bytes";
                    }
    
                    leaf bytes67 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "6th and 7th Bytes";
                    }
    
                    leaf bytes89 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "8th and 9th Bytes";
                    }
    
                    leaf type {
                      type Ethernet-segment-identifier;
                      mandatory true;
                      description
                        "Ethernet segment identifier type";
                    }
                  }  // container identifier
    
                  container preference-based-service-carving {
                    description
                      "Preference-Based DF Election Configuration
    Options";
                    leaf weight {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Preference DF weight. For Access-Driven DF, use
    weights of at most 32767 or less.";
                    }
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Preference Based Service Carving";
                    }
    
                    leaf access-driven {
                      type empty;
                      description
                        "Enable Access-Driven DF Election";
                    }
                  }  // container preference-based-service-carving
    
                  container manual-service-carving {
                    description
                      "Enter Manual service carving configuration
    submode";
                    container service-list {
                      description
                        "Manual service carving primary,secondary lists";
                      leaf primary {
                        type string {
                          length "1..150";
                        }
                        description
                          "Primary services list";
                      }
    
                      leaf secondary {
                        type string {
                          length "1..150";
                        }
                        description
                          "Secondary services list";
                      }
                    }  // container service-list
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Manual service carving";
                    }
                  }  // container manual-service-carving
                }  // container evpn-virtual-ethernet-segment
              }  // list evpn-virtual-access-vfi
            }  // container evpn-virtual-access-vfis
    
            container evpn-load-balancing {
              description
                "Enter EVPN Loadbalancing configuration submode";
              leaf evpn-static-flow-label {
                type empty;
                description
                  "Enable Static Flow Label based load balancing";
              }
    
              leaf enable {
                type empty;
                description
                  "Enable EVPN Loadbalancing";
              }
            }  // container evpn-load-balancing
    
            container evpn-bgp-auto-discovery {
              description
                "Enable Autodiscovery BGP in EVPN";
              leaf enable {
                type empty;
                description
                  "Enable Autodiscovery BGP";
              }
    
              container evpn-route-distinguisher {
                description
                  "Route Distinguisher";
                leaf type {
                  type Bgp-route-distinguisher;
                  description
                    "Router Distinguisher Type";
                }
    
                leaf as {
                  when
                    "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                    description
                      "../Type = TwoByteAS or ../Type = FourByteAS";
                  }
                  type Rdas-range;
                  description
                    "Two byte or 4 byte AS number";
                }
    
                leaf as-index {
                  when
                    "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                    description
                      "../Type = TwoByteAS or ../Type = FourByteAS";
                  }
                  type Rdas-index;
                  description
                    "AS:nn (hex or decimal format)";
                }
    
                leaf address {
                  when
                    "../type = 'ipv4-address'" {
                    description
                      "../Type = IPV4Address";
                  }
                  type inet:ipv4-address-no-zone;
                  description "IPV4 address";
                }
    
                leaf addr-index {
                  when
                    "../type = 'ipv4-address'" {
                    description
                      "../Type = IPV4Address";
                  }
                  type Rd-addr-index;
                  description "Addr index";
                }
              }  // container evpn-route-distinguisher
            }  // container evpn-bgp-auto-discovery
    
            container evpn-groups {
              description
                "Enter EVPN Group Table submode";
              list evpn-group {
                key "group-id";
                description
                  "Enter EVPN Group submode";
                container evpn-group-core-interfaces {
                  description
                    "EVPN Group core interfaces";
                  list evpn-group-core-interface {
                    key "interface-name";
                    description
                      "EVPN Group Core interface";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Name of the EVPN Group core interface";
                    }
                  }  // list evpn-group-core-interface
                }  // container evpn-group-core-interfaces
    
                leaf group-id {
                  type Evpn-group-id-range;
                  description "Group ID";
                }
              }  // list evpn-group
            }  // container evpn-groups
    
            container evpn-instances {
              description
                "Enter EVPN Instance configuration submode";
              list evpn-instance {
                key "vpn-id encapsulation side";
                description
                  "Enter EVPN Instance configuration submode";
                container evpn-instance-bgp-auto-discovery {
                  description
                    "Enable Autodiscovery BGP in EVPN Instance";
                  container evpn-route-policy {
                    description "Route policy";
                    leaf export {
                      type string;
                      description
                        "Export route policy";
                    }
    
                    leaf import {
                      type string;
                      description
                        "Import route policy";
                    }
                  }  // container evpn-route-policy
    
                  container evpn-route-targets {
                    description "Route Target";
                    list evpn-route-target {
                      must
                        "none or two-byte-as-or-four-byte-as or ipv4-address" {
                        description
                          "None or TwoByteAS-or-FourByteAS or
    IPV4Address must be present.";
                      }
                      key "role format";
                      description
                        "Name of the Route Target";
                      leaf format {
                        type Bgp-route-target-format;
                        description
                          "Format of the route target";
                      }
    
                      leaf role {
                        type Bgp-route-target-role;
                        description
                          "Role of the router target type";
                      }
    
                      list none {
                        when
                          "../format = 'none'" {
                          description
                            "../Format = None";
                        }
                        key "stitching";
                        description "none";
                        leaf stitching {
                          type Bgp-route-target;
                          description
                            "whether RT is Stitching RT (DEPRECATED)";
                        }
                      }  // list none
    
                      list two-byte-as-or-four-byte-as {
                        when
                          "../format = 'two-byte-as' or ../format = 'four-byte-as'" {
                          description
                            "../Format = TwoByteAS or ../Format =
    FourByteAS";
                        }
                        key "as as-index stitching";
                        description
                          "two byte as or four byte as";
                        leaf as {
                          type Rdas-range;
                          description
                            "Two byte or 4 byte AS number";
                        }
    
                        leaf as-index {
                          type Rdas-index;
                          description
                            "AS:nn (hex or decimal format)";
                        }
    
                        leaf stitching {
                          type Bgp-route-target;
                          description
                            "whether RT is Stitching RT (DEPRECATED)";
                        }
                      }  // list two-byte-as-or-four-byte-as
    
                      list ipv4-address {
                        when
                          "../format = 'ipv4-address'" {
                          description
                            "../Format = IPV4Address";
                        }
                        key "address addr-index stitching";
                        description
                          "ipv4 address";
                        leaf address {
                          type inet:ipv4-address-no-zone;
                          description
                            "IPV4 address";
                        }
    
                        leaf addr-index {
                          type Rd-addr-index;
                          description
                            "Addr index";
                        }
    
                        leaf stitching {
                          type Bgp-route-target;
                          description
                            "whether RT is Stitching RT (DEPRECATED)";
                        }
                      }  // list ipv4-address
                    }  // list evpn-route-target
                  }  // container evpn-route-targets
    
                  leaf table-policy {
                    type string;
                    description
                      "Table Policy for installation of forwarding
    data to L2FIB";
                  }
    
                  leaf implicit-import-disable {
                    type empty;
                    description
                      "Disables BGP Implicit Import";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Autodiscovery BGP";
                  }
    
                  container evpn-route-distinguisher {
                    description
                      "Route Distinguisher";
                    leaf type {
                      type Bgp-route-distinguisher;
                      description
                        "Router Distinguisher Type";
                    }
    
                    leaf as {
                      when
                        "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                        description
                          "../Type = TwoByteAS or ../Type = FourByteAS";
                      }
                      type Rdas-range;
                      description
                        "Two byte or 4 byte AS number";
                    }
    
                    leaf as-index {
                      when
                        "../type = 'two-byte-as' or ../type = 'four-byte-as'" {
                        description
                          "../Type = TwoByteAS or ../Type = FourByteAS";
                      }
                      type Rdas-index;
                      description
                        "AS:nn (hex or decimal format)";
                    }
    
                    leaf address {
                      when
                        "../type = 'ipv4-address'" {
                        description
                          "../Type = IPV4Address";
                      }
                      type inet:ipv4-address-no-zone;
                      description "IPV4 address";
                    }
    
                    leaf addr-index {
                      when
                        "../type = 'ipv4-address'" {
                        description
                          "../Type = IPV4Address";
                      }
                      type Rd-addr-index;
                      description "Addr index";
                    }
                  }  // container evpn-route-distinguisher
                }  // container evpn-instance-bgp-auto-discovery
    
                container evpn-instance-etree {
                  description
                    "Enter EVPN E-Tree configuration submode";
                  leaf evpn-instance-etree-rt-leaf {
                    type empty;
                    description
                      "Configure E-Tree as Route-Target leaf";
                  }
    
                  leaf evpn-instance-etree-leaf {
                    type empty;
                    description
                      "Configure E-Tree as leaf";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable EVPN E-Tree";
                  }
                }  // container evpn-instance-etree
    
                container evpn-instance-advertise-mac {
                  description
                    "Enter Advertise local MAC-only routes
    configuration submode";
                  leaf evi-advertise-mac-bvi {
                    type empty;
                    description
                      "Advertise local MAC-only and BVI MAC routes";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Advertise local MAC-only routes";
                  }
                }  // container evpn-instance-advertise-mac
    
                container evpn-instance-multicast {
                  description
                    "Enter Multicast configuration submode";
                  leaf evi-mcast-source-connected {
                    type empty;
                    description
                      "Enable Multicast source connectivity";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Multicast";
                  }
                }  // container evpn-instance-multicast
    
                container evpn-instance-load-balancing {
                  description
                    "Enter Loadbalancing configuration submode";
                  leaf evi-static-flow-label {
                    type empty;
                    description
                      "Enable Static Flow Label based load
    balancing";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Loadbalancing";
                  }
                }  // container evpn-instance-load-balancing
    
                leaf evpn-route-sync-vrf-default {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description
                    "Set EVI for default VRF";
                }
    
                leaf evi-srv6-locator {
                  type string {
                    length "1..58";
                  }
                  description
                    "Specify SRv6 locator name";
                }
    
                leaf evi-reorig-disable {
                  type empty;
                  description
                    "Disable route re-origination";
                }
    
                leaf evi-preferred-nexthop {
                  type Preferred-nexthop-mode;
                  description
                    "Enable Preferred Nexthop mode on this EVI";
                }
    
                leaf evpn-evi-transmit-mtu-zero {
                  type boolean;
                  description
                    "Transmit MTU zero to remote for this EVPN EVI
    .";
                }
    
                leaf evpn-instance-description {
                  type string {
                    length "1..64";
                  }
                  description
                    "Description for EVPN Instance";
                }
    
                leaf evpn-evi-mtu-mismatch-ignore {
                  type boolean;
                  description
                    "Ignore mismatch between local and remote MTUs
    for this EVPN EVI.";
                }
    
                leaf evi-ecmp-disable {
                  type empty;
                  description
                    "Disable ECMP on the EVI";
                }
    
                leaf evpn-evi-mtu-match-enforce {
                  type empty;
                  description
                    "Enforce matching between local and remote
    MTUs for this EVPN EVI.";
                }
    
                leaf evpn-instance-vpws-single-active-backup-suppression {
                  type empty;
                  description
                    "Configure EVPN VPWS Single-Active Backup
    Suppression";
                }
    
                leaf evpn-evi-transmit-l2-mtu {
                  type empty;
                  description
                    "Transmit L2 MTU to remote for this EVPN EVI.";
                }
    
                leaf evi-unknown-unicast-flooding-disable {
                  type empty;
                  description
                    "Disable Unknown Unicast Flooding on this EVI";
                }
    
                leaf evi-bvi-coupled-mode {
                  type empty;
                  description
                    "When configured, the associated EVPN core
    port will keep the BVI Up in case of AC
    failure";
                }
    
                leaf evpn-evi-cw-disable {
                  type empty;
                  description
                    "CW disable for EVPN EVI";
                }
    
                leaf vpn-id {
                  type Vpnid-range;
                  description "EVPN Instance ID";
                }
    
                leaf encapsulation {
                  type Evpn-encapsulation;
                  description
                    "EVPN Instance Encapsulation";
                }
    
                leaf side {
                  type Evpn-side;
                  description
                    "EVPN Instance Side";
                }
              }  // list evpn-instance
            }  // container evpn-instances
    
            container evpn-logging {
              description
                "Enter EVPN Logging configuration submode";
              leaf evpn-df-election {
                type empty;
                description
                  "Enable Designated Forwarder election logging";
              }
    
              leaf enable {
                type empty;
                description
                  "Enable EVPN Logging";
              }
            }  // container evpn-logging
    
            container evpn-segment-routing-srv6 {
              description
                "Enter EVPN Segment-Routing SRv6 submode";
              leaf evpn-srv6-locator {
                type string {
                  length "1..58";
                }
                description
                  "Specify default SRv6 locator name";
              }
    
              leaf enable {
                type empty;
                description
                  "Enable EVPN Segment-Routing SRv6";
              }
            }  // container evpn-segment-routing-srv6
    
            container evpn-interfaces {
              description
                "Attachment Circuit interfaces";
              list evpn-interface {
                key "interface-name";
                description
                  "Attachment circuit interface";
                container evpnac-timers {
                  description
                    "Enter Interface-specific timers configuration
    submode";
                  leaf evpnac-peering {
                    type uint32 {
                      range "0..300";
                    }
                    default "3";
                    description
                      "Interface-specific Peering timer";
                  }
    
                  leaf evpnac-debounce {
                    type uint32 {
                      range "0..300000";
                    }
                    default "3000";
                    description
                      "Interface-specific AC Debounce timer";
                  }
    
                  leaf evpnac-carving {
                    type uint32 {
                      range "0..300";
                    }
                    default "0";
                    description
                      "Interface-specific Carving timer";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Interface-specific timers";
                  }
    
                  leaf evpnac-recovery {
                    type uint32 {
                      range "0..3600";
                    }
                    default "30";
                    description
                      "Interface-specific Recovery timer";
                  }
                }  // container evpnac-timers
    
                container ethernet-segment {
                  description
                    "Enter Ethernet Segment configuration submode";
                  container es-convergence {
                    description
                      "Convergence mode(s) and configuration
    options";
                    leaf mac-mobility {
                      type empty;
                      description
                        "Enable MAC-mobility triggered flush";
                    }
    
                    leaf nh-tracking {
                      type empty;
                      description
                        "Nexthop-tracking influenced DF Election";
                    }
    
                    leaf reroute {
                      type empty;
                      description
                        "Enable reroute to backup peer";
                    }
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Convergence configuration options";
                    }
                  }  // container es-convergence
    
                  leaf force-single-homed {
                    type empty;
                    description
                      "Force ethernet segment to remain
    single-homed";
                  }
    
                  leaf load-balancing-mode {
                    type Ethernet-segment-load-balance;
                    description
                      "Ethernet-Segment Load Balancing mode";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Ethernet Segment";
                  }
    
                  leaf backbone-source-mac {
                    type yang:mac-address;
                    description
                      "Backbone Source MAC";
                  }
    
                  leaf service-carving-mcast-type {
                    type Ethernet-segment-service-carving-mcast;
                    description
                      "Ethernet-Segment Service Carving multicast mode";
                  }
    
                  leaf es-import-route-target {
                    type yang:mac-address;
                    description
                      "ES-Import Route Target";
                  }
    
                  leaf service-carving-type {
                    type Ethernet-segment-service-carving;
                    description
                      "Ethernet-Segment Service Carving mode";
                  }
    
                  container identifier {
                    presence
                      "Indicates a identifier node is configured.";
                    description
                      "Ethernet segment identifier";
                    leaf bytes01 {
                      type xr:Hex-integer;
                      mandatory true;
                      description
                        "Type 0's 1st Byte or Type Byte and 1st Byte";
                    }
    
                    leaf bytes23 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "2nd and 3rd Bytes";
                    }
    
                    leaf bytes45 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "4th and 5th Bytes";
                    }
    
                    leaf bytes67 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "6th and 7th Bytes";
                    }
    
                    leaf bytes89 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "8th and 9th Bytes";
                    }
    
                    leaf type {
                      type Ethernet-segment-identifier;
                      mandatory true;
                      description
                        "Ethernet segment identifier type";
                    }
                  }  // container identifier
    
                  container preference-based-service-carving {
                    description
                      "Preference-Based DF Election Configuration
    Options";
                    leaf weight {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Preference DF weight. For Access-Driven DF, use
    weights of at most 32767 or less.";
                    }
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Preference Based Service Carving";
                    }
    
                    leaf access-driven {
                      type empty;
                      description
                        "Enable Access-Driven DF Election";
                    }
                  }  // container preference-based-service-carving
    
                  container manual-service-carving {
                    description
                      "Enter Manual service carving configuration
    submode";
                    container service-list {
                      description
                        "Manual service carving primary,secondary lists";
                      leaf primary {
                        type string {
                          length "1..150";
                        }
                        description
                          "Primary services list";
                      }
    
                      leaf secondary {
                        type string {
                          length "1..150";
                        }
                        description
                          "Secondary services list";
                      }
                    }  // container service-list
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Manual service carving";
                    }
                  }  // container manual-service-carving
                }  // container ethernet-segment
    
                leaf evpn-core-isolation-group {
                  type Evpn-core-group-id-range;
                  description
                    "Enter EVPN Core Isolation Group ID";
                }
    
                leaf evpn-access-signal-mode {
                  type Interface-access-signal-mode;
                  description
                    "Override default signal sent to bring down
    access circuit";
                }
    
                leaf mac-flush {
                  type Mac-flush-mode;
                  description
                    "Enable MAC Flushing";
                }
    
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Name of the attachment circuit interface";
                }
              }  // list evpn-interface
            }  // container evpn-interfaces
    
            container evpn-virtual-access-pws {
              description
                "Virtual Access Pseudowire interfaces";
              list evpn-virtual-access-pw {
                key "neighbor pseudowire-id";
                description
                  "Virtual Access Pseudowire";
                container evpn-virtual-access-pw-timers {
                  description
                    "Enter Virtual Access Pseudowire-specific
    timers configuration submode";
                  leaf evpn-virtual-access-pw-recovery {
                    type uint32 {
                      range "0..3600";
                    }
                    default "30";
                    description
                      "Virtual Access Pseudowire-specific Recovery
    timer";
                  }
    
                  leaf evpn-virtual-access-pw-debounce {
                    type uint32 {
                      range "0..300000";
                    }
                    default "3000";
                    description
                      "Virtual Access Pseudowire-specific AC
    Debounce timer";
                  }
    
                  leaf evpn-virtual-access-pw-peering {
                    type uint32 {
                      range "0..300";
                    }
                    default "3";
                    description
                      "Virtual Access Pseudowire-specific Peering
    timer";
                  }
    
                  leaf enable {
                    type empty;
                    description
                      "Enable Virtual Access Pseudowire-specific
    timers";
                  }
    
                  leaf evpn-virtual-access-pw-carving {
                    type uint32 {
                      range "0..300";
                    }
                    default "0";
                    description
                      "Virtual Access Pseudowire-specific Carving
    timer";
                  }
                }  // container evpn-virtual-access-pw-timers
    
                leaf neighbor {
                  type inet:ipv4-address-no-zone;
                  description
                    "Neighbor IP address";
                }
    
                leaf pseudowire-id {
                  type Pseudowire-id-range;
                  description "Pseudowire ID";
                }
    
                container evpn-virtual-ethernet-segment {
                  description
                    "Enter Ethernet Segment configuration submode";
                  leaf enable {
                    type empty;
                    description
                      "Enable Ethernet Segment";
                  }
    
                  leaf service-carving-mcast-type {
                    type Ethernet-segment-service-carving-mcast;
                    description
                      "Ethernet-Segment Service Carving multicast mode";
                  }
    
                  leaf es-import-route-target {
                    type yang:mac-address;
                    description
                      "ES-Import Route Target";
                  }
    
                  leaf service-carving-type {
                    type Ethernet-segment-service-carving;
                    description
                      "Ethernet-Segment Service Carving mode";
                  }
    
                  container identifier {
                    presence
                      "Indicates a identifier node is configured.";
                    description
                      "Ethernet segment identifier";
                    leaf bytes01 {
                      type xr:Hex-integer;
                      mandatory true;
                      description
                        "Type 0's 1st Byte or Type Byte and 1st Byte";
                    }
    
                    leaf bytes23 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "2nd and 3rd Bytes";
                    }
    
                    leaf bytes45 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "4th and 5th Bytes";
                    }
    
                    leaf bytes67 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "6th and 7th Bytes";
                    }
    
                    leaf bytes89 {
                      type xr:Hex-integer;
                      units "byte";
                      mandatory true;
                      description
                        "8th and 9th Bytes";
                    }
    
                    leaf type {
                      type Ethernet-segment-identifier;
                      mandatory true;
                      description
                        "Ethernet segment identifier type";
                    }
                  }  // container identifier
    
                  container preference-based-service-carving {
                    description
                      "Preference-Based DF Election Configuration
    Options";
                    leaf weight {
                      type uint32 {
                        range "0..65535";
                      }
                      description
                        "Preference DF weight. For Access-Driven DF, use
    weights of at most 32767 or less.";
                    }
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Preference Based Service Carving";
                    }
    
                    leaf access-driven {
                      type empty;
                      description
                        "Enable Access-Driven DF Election";
                    }
                  }  // container preference-based-service-carving
    
                  container manual-service-carving {
                    description
                      "Enter Manual service carving configuration
    submode";
                    container service-list {
                      description
                        "Manual service carving primary,secondary lists";
                      leaf primary {
                        type string {
                          length "1..150";
                        }
                        description
                          "Primary services list";
                      }
    
                      leaf secondary {
                        type string {
                          length "1..150";
                        }
                        description
                          "Secondary services list";
                      }
                    }  // container service-list
    
                    leaf enable {
                      type empty;
                      description
                        "Enable Manual service carving";
                    }
                  }  // container manual-service-carving
                }  // container evpn-virtual-ethernet-segment
              }  // list evpn-virtual-access-pw
            }  // container evpn-virtual-access-pws
    
            container evpn-ethernet-segment {
              description
                "EVPN Global Ethernet Segment submode";
              container evpn-esi-types {
                description
                  "EVPN ESI type table";
                list evpn-esi-type {
                  key "esi-type";
                  description "ESI type";
                  leaf disable-auto-generation {
                    type empty;
                    description
                      "Disable ESI Autogeneration";
                  }
    
                  leaf esi-type {
                    type Evpn-esi-type-range;
                    description "ESI type";
                  }
                }  // list evpn-esi-type
              }  // container evpn-esi-types
    
              leaf enable {
                type empty;
                description
                  "Enable EVPN Global Ethernet Segment submode";
              }
            }  // container evpn-ethernet-segment
    
            leaf evpn-global-transmit-mtu-zero {
              type empty;
              description
                "Transmit MTU zero to remote for all EVIs";
            }
    
            leaf evpn-global-mtu-mismatch-ignore {
              type empty;
              description
                "Ignore mismatch between local and remote MTUs
    for all EVIs.";
            }
    
            leaf evpn-global-mtu-match-enforce {
              type empty;
              description
                "Enforce matching between local and remote MTUs
    for all EVIs.";
            }
    
            leaf evpn-global-transmit-l2-mtu {
              type empty;
              description
                "Transmit L2 MTU to remote for all EVIs";
            }
    
            leaf evpn-staggered-bringup {
              type uint32 {
                range "0..300000";
              }
              units "millisecond";
              default "5000";
              description
                "Staggered bringup (milliseconds) timer";
            }
    
            leaf evi-cost-out {
              type empty;
              description
                "Configure node to cost-out";
            }
    
            leaf evpn-source-interface {
              type xr:Interface-name;
              description
                "Configure EVPN router-id implicitly through
    Loopback Interface";
            }
    
            leaf evpn-cost-in-startup {
              type uint32 {
                range "30..86400";
              }
              units "second";
              description
                "Cost-in node after given time (seconds) on
    startup timer";
            }
          }  // container evpn-tables
    
          leaf enable {
            type empty;
            description "Enable EVPN feature";
          }
        }  // container evpn
      }  // module Cisco-IOS-XR-l2vpn-cfg
    

© 2023 YumaWorks, Inc. All rights reserved.