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

    yang-version 1;

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

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

    include Cisco-IOS-XR-l2vpn-oper-sub1 {
      revision-date "2020-05-05";
    }

    organization "Cisco Systems, Inc.";

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

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

    revision "2020-05-05" {
      description
        "changes related to treat SRv6 and SID as well-known when parsing XML for yang";
    }

    revision "2020-04-28" {
      description
        "- AC Backup related changes
       2020-01-22
       - PWGROUP related changes
       2019-12-20
       - EVPN-VPWS related changes - SR-TE policy related changes";
    }

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

    revision "2019-03-30" {
      description
        "- Rename l2fib-mac-learning-mac* interface-handle to interface-name - Rename l2fib-pw-group tunnel-if-handle to tunnel-interface-name - Convert several array from leaf-list to list syntax. - Implement range datatypes for all L2FIB integers.";
    }

    revision "2018-08-01" {
      description "Removed empty groupings.";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    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 L2vpn-memory-state {
      type enumeration {
        enum "memory-state-unknown" {
          value 0;
          description "Memory state Unknown";
        }
        enum "memory-state-normal" {
          value 1;
          description "Memory state Normal";
        }
        enum "memory-state-minor" {
          value 2;
          description "Memory state Minor";
        }
        enum "memory-state-severe" {
          value 3;
          description "Memory state Severe";
        }
        enum "memory-state-critical" {
          value 4;
          description
            "Memory state Critical";
        }
        enum "memory-state-invalid" {
          value 5;
          description "Memory state Invalid";
        }
      }
      description "L2vpn memory state";
    }

    typedef L2vpn-ac-encap {
      type enumeration {
        enum "unknown-encap" {
          value 0;
          description "unknown encap";
        }
        enum "vlan" {
          value 1;
          description "vlan";
        }
        enum "qinq" {
          value 2;
          description "qinq";
        }
        enum "qin-any" {
          value 3;
          description "qin any";
        }
        enum "ethernet" {
          value 4;
          description "ethernet";
        }
        enum "atm-aal0" {
          value 5;
          description "atm aal0";
        }
        enum "atm-aal5" {
          value 6;
          description "atm aal5";
        }
        enum "atm-vp" {
          value 7;
          description "atm vp";
        }
        enum "atm-port" {
          value 8;
          description "atm port";
        }
        enum "hdlc" {
          value 9;
          description "hdlc";
        }
        enum "fr-dlci" {
          value 10;
          description "fr dlci";
        }
        enum "fr-dlci-local" {
          value 11;
          description "fr dlci local";
        }
        enum "ppp" {
          value 12;
          description "ppp";
        }
        enum "tdm-sa-to-p-e1" {
          value 13;
          description "tdm sa to p e1";
        }
        enum "tdm-sa-to-p-t1" {
          value 14;
          description "tdm sa to p t1";
        }
        enum "tdm-sa-to-p-e3" {
          value 15;
          description "tdm sa to p e3";
        }
        enum "tdm-sa-to-p-t3" {
          value 16;
          description "tdm sa to p t3";
        }
        enum "tdm-ce-so-psn" {
          value 17;
          description "tdm ce so psn";
        }
        enum "ip" {
          value 18;
          description "ip";
        }
        enum "vlan-encap" {
          value 19;
          description "vlan encap";
        }
        enum "dot1ad" {
          value 20;
          description "dot1ad";
        }
        enum "efp" {
          value 21;
          description "efp";
        }
        enum "bvi" {
          value 22;
          description "bvi";
        }
        enum "monitor-session" {
          value 23;
          description "monitor session";
        }
        enum "pseudowire-ether" {
          value 24;
          description "pseudowire ether";
        }
        enum "pseudowire-iw" {
          value 25;
          description "pseudowire iw";
        }
        enum "multi-segment-pseudowire" {
          value 26;
          description
            "multi segment pseudowire";
        }
        enum "pseudowire-l2-subinterface" {
          value 27;
          description
            "pseudowire l2 subinterface";
        }
        enum "virtual-network-interface" {
          value 28;
          description
            "virtual network interface";
        }
        enum "vlan-switched-port" {
          value 29;
          description "vlan switched port";
        }
        enum "vlan-switched-port-vlan" {
          value 30;
          description
            "vlan switched port vlan";
        }
        enum "encap-types-max" {
          value 31;
          description "encap types max";
        }
      }
      description "L2vpn ac encap";
    }

    typedef L2vpn-brief-psn {
      type enumeration {
        enum "ls" {
          value 0;
          description "ls";
        }
        enum "atom" {
          value 1;
          description "atom";
        }
        enum "l2tpv3" {
          value 2;
          description "l2tpv3";
        }
        enum "evpn-vpws" {
          value 3;
          description "evpn vpws";
        }
        enum "unknown-psn" {
          value 4;
          description "unknown psn";
        }
      }
      description "L2vpn brief psn";
    }

    typedef L2vpn-src-address-set {
      type enumeration {
        enum "unset" {
          value 0;
          description "Unset";
        }
        enum "set" {
          value 1;
          description "Set";
        }
      }
      description "L2vpn src address set";
    }

    typedef L2vpn-transport-mode {
      type enumeration {
        enum
          "l2vpn-transport-mode-not-specified" {
          value 0;
          description "Not specified";
        }
        enum "l2vpn-transport-mode-ethernet" {
          value 1;
          description "Ethernet";
        }
        enum "l2vpn-transport-mode-vlan" {
          value 2;
          description "VLAN";
        }
        enum
          "l2vpn-transport-mode-vlan-passthrough" {
          value 3;
          description "VLAN Passthrough";
        }
      }
      description "L2vpn transport mode";
    }

    typedef L2vpn-pw-class-control-word {
      type enumeration {
        enum "unset" {
          value 0;
          description "Unset";
        }
        enum "enable" {
          value 1;
          description "Enable";
        }
        enum "disable" {
          value 2;
          description "Disable";
        }
      }
      description
        "L2vpn pw class control word";
    }

    typedef L2vpn-g8032-uncfg-reason {
      type enumeration {
        enum "reason-none" {
          value 0;
          description "No reason";
        }
        enum "ring-mp0-missing" {
          value 1;
          description "Main port0 missing";
        }
        enum "ring-mp1-missing" {
          value 2;
          description "Main port1 missing";
        }
        enum "inclusion-list-empty" {
          value 3;
          description "Inclusion list empty";
        }
        enum "aps0-missing" {
          value 4;
          description "APS port0 missing";
        }
        enum "aps0bp-notfound" {
          value 5;
          description
            "APS port0 not found as valid BP";
        }
        enum "aps0-no-ac-ctx" {
          value 6;
          description
            "APS port0 has no valid AC context";
        }
        enum "aps0-not-in-inclusion-list" {
          value 7;
          description
            "APS port0 not in inclusion list";
        }
        enum "aps0-mismatched" {
          value 8;
          description
            "APS port0 mismatched with main port";
        }
        enum "aps1-missing" {
          value 9;
          description "APS port1 missing";
        }
        enum "aps1bp-notfound" {
          value 10;
          description
            "APS port1 not found as valid BP";
        }
        enum "aps1-no-ac-ctx" {
          value 11;
          description
            "APS port1 has no valid AC context";
        }
        enum "aps1-not-in-inclusion-list" {
          value 12;
          description
            "APS port1 not in inclusion list";
        }
        enum "aps1-mismatched" {
          value 13;
          description
            "APS port1 mismatched with main port";
        }
        enum "aps-unprovisioned" {
          value 14;
          description "APS AC unrpvosioned";
        }
      }
      description
        "Unresolved reason for G8032 ring instance";
    }

    typedef L2vpn-g8032-rpl {
      type enumeration {
        enum "rpl-unknown" {
          value 0;
          description "No RPL info";
        }
        enum "port0-owner" {
          value 1;
          description "Port 0 owner";
        }
        enum "port0-neighbor" {
          value 2;
          description "Port 0 neighbor";
        }
        enum "port0-next-neighbor" {
          value 3;
          description "Port 0 next neighbor";
        }
        enum "port1-owner" {
          value 4;
          description "Port 1 owner";
        }
        enum "port1-neighbor" {
          value 5;
          description "Port 1 neighbor";
        }
        enum "port1-next-neighbor" {
          value 6;
          description "Port 1 next neighbor";
        }
      }
      description "RPL types in g8032 ring";
    }

    typedef L2vpn-ipc-transport-mode {
      type enumeration {
        enum "unicast" {
          value 0;
          description
            "L2VPN Unicast IPC transport mode";
        }
        enum "broadcast" {
          value 1;
          description
            "L2VPN Broadcast IPC transport mode";
        }
        enum "unknown" {
          value 2;
          description
            "L2VPN Unknown IPC transport mode";
        }
      }
      description "L2vpn ipc transport mode";
    }

    typedef L2vpn-vni-mode {
      type enumeration {
        enum "l2vpn-vni-mode-l2-dp" {
          value 0;
          description
            "Data Plane L2 Service";
        }
        enum "l2vpn-vni-mode-l3-dp" {
          value 1;
          description
            "Data Plane L3 Service";
        }
        enum "l2vpn-vni-mode-l2-cp" {
          value 2;
          description
            "Control Plane L2 Service";
        }
        enum "l2vpn-vni-mode-l3-cp" {
          value 3;
          description
            "Control Plane L3 Service";
        }
      }
      description "L2vpn vni mode";
    }

    typedef L2vpn-vni-encaps {
      type enumeration {
        enum "l2vpn-vni-encap-vxlan" {
          value 0;
          description "VXLAN";
        }
        enum "l2vpn-vni-encap-softgre" {
          value 1;
          description "SOFTGRE";
        }
      }
      description "L2vpn vni encaps";
    }

    typedef L2vpn-mirp-lite-protocol-info {
      type enumeration {
        enum "vlan0" {
          value 0;
          description "MVRP PDU using Vlan0";
        }
        enum "none" {
          value 1;
          description "none";
        }
      }
      description
        "L2vpn mirp lite protocol info";
    }

    typedef L2vpn-mirp-lite-status {
      type enumeration {
        enum "enabled" {
          value 0;
          description "Supported, enabled";
        }
        enum "not-supported" {
          value 1;
          description "Not supported";
        }
      }
      description "L2vpn mirp lite status";
    }

    typedef L2vpn-virtualport-state {
      type enumeration {
        enum "l2vpn-vp-state-undefined" {
          value 0;
          description "Undefined";
        }
        enum "l2vpn-vp-state-up" {
          value 1;
          description "Up";
        }
        enum "l2vpn-vp-state-down" {
          value 2;
          description "Down";
        }
      }
      description "L2vpn virtualport state";
    }

    typedef L2vpn-bridge {
      type enumeration {
        enum "l2vpn-bridge-type-default" {
          value 0;
          description
            "Regular none PBB bridge";
        }
        enum "l2vpn-bridge-type-pbb-edge" {
          value 1;
          description "PBB edge bridge";
        }
        enum "l2vpn-bridge-type-pbb-core" {
          value 2;
          description "PBB core bridge";
        }
      }
      description "L2vpn bridge";
    }

    typedef P2mp-transport-state {
      type enumeration {
        enum "none" {
          value 0;
          description
            "no information about the transport yet";
        }
        enum "ok" {
          value 1;
          description "transport up";
        }
        enum "error" {
          value 2;
          description "transport error";
        }
        enum "tunnel-down" {
          value 3;
          description "tunnel is down";
        }
        enum "max-tunnels-reached" {
          value 4;
          description
            "transport down because the maximum number of
           tunnels is reached";
        }
      }
      description "P2mp transport state";
    }

    typedef L2vpn-vfi-p2mp-signaling {
      type enumeration {
        enum "none" {
          value 0;
          description "undefined signaling";
        }
        enum "bgp" {
          value 1;
          description "BGP signaling";
        }
      }
      description "L2vpn vfi p2mp signaling";
    }

    typedef L2vpn-vfi-p2mp-transport {
      type enumeration {
        enum "none" {
          value 0;
          description "undefined transport";
        }
        enum "rsvp-te" {
          value 1;
          description "RSVP-TE transport";
        }
      }
      description "L2vpn vfi p2mp transport";
    }

    typedef L2vpn-vfi-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "VFI Unknown";
        }
        enum "up" {
          value 1;
          description "VFI Up";
        }
        enum "down" {
          value 2;
          description "VFI Down";
        }
        enum "admin-down" {
          value 3;
          description "VFI Admin Down";
        }
      }
      description "L2vpn vfi state";
    }

    typedef L2vpn-bag-mac-withdraw-option {
      type enumeration {
        enum "mac-withdraw-option-state-up" {
          value 0;
          description
            "Mac withdraw on state up";
        }
        enum
          "mac-withdraw-option-state-down" {
          value 1;
          description
            "Mac withdraw on state down";
        }
        enum "mac-withdraw-option-optimize" {
          value 2;
          description
            "Optimized Mac withdraw";
        }
      }
      description
        "L2vpn bag mac withdraw option";
    }

    typedef L2vpn-bridge-coupled-state {
      type enumeration {
        enum "disabled" {
          value 0;
          description
            "Coupled mode disabled";
        }
        enum "down" {
          value 2;
          description "Coupled state down";
        }
        enum "up" {
          value 3;
          description "Coupled state up";
        }
      }
      description
        "L2vpn bridge coupled state";
    }

    typedef L2vpn-bridge-state {
      type enumeration {
        enum "bridge-init" {
          value 0;
          description "Bridge Init State";
        }
        enum "bridge-up" {
          value 1;
          description "Bridge Up";
        }
        enum "bridge-down" {
          value 2;
          description "Bridge Down";
        }
        enum "bridge-admin-down" {
          value 3;
          description "Bridge Admin Down";
        }
      }
      description "L2vpn bridge state";
    }

    typedef L2vpn-bag-l2mc-src-traffic {
      type enumeration {
        enum "l2mc-none" {
          value 0;
          description
            "L2MC Source Traffic None";
        }
        enum "l2mcipv4" {
          value 1;
          description
            "L2MC Source Traffic:IPv4";
        }
        enum "l2mcipv6" {
          value 2;
          description
            "L2MC Source Traffic:IPv6";
        }
        enum "l2mcipv4ipv6" {
          value 3;
          description
            "L2MC Source Traffic:IPv4/IPv6";
        }
      }
      description
        "L2vpn bag l2mc src traffic";
    }

    typedef L2vpn-bag-storm-control-rate-unit {
      type enumeration {
        enum "pps" {
          value 0;
          description "Packets Per Second";
        }
        enum "kb-ps" {
          value 1;
          description "Kilobits Per Second";
        }
      }
      description
        "Storm Control Rate Unit Type";
    }

    typedef L2vpn-bag-mac-secure-action {
      type enumeration {
        enum "not-set" {
          value 0;
          description
            "MAC Secure Action Not Set";
        }
        enum "restrict" {
          value 1;
          description
            "MAC Secure Action Restrict";
        }
        enum "none" {
          value 2;
          description
            "MAC Secure Action None";
        }
        enum "shutdown" {
          value 3;
          description
            "MAC Secure Action Shutdown";
        }
      }
      description
        "L2vpn bag mac secure action";
    }

    typedef L2vpn-bag-mac-aging-mode {
      type enumeration {
        enum "aging-none" {
          value 0;
          description "MAC Aging None";
        }
        enum "aging-absolute" {
          value 1;
          description "Mac Aging Absolute";
        }
        enum "aging-inactivity" {
          value 2;
          description "Mac Aging Inactivity";
        }
      }
      description "L2vpn bag mac aging mode";
    }

    typedef L2vpn-bag-mac-limit-notify {
      type enumeration {
        enum "mac-limit-notify-none" {
          value 0;
          description
            "MAC Limit Notify None";
        }
        enum "mac-limit-notify-syslog" {
          value 1;
          description
            "MAC Limit Notify Syslog";
        }
        enum "mac-limit-notify-trap" {
          value 2;
          description
            "MAC Limit Notify Trap";
        }
        enum "mac-limit-notify-syslog-trap" {
          value 3;
          description
            "MAC Limit Notify Syslog and Trap";
        }
        enum "mac-limit-notify-no-config" {
          value 4;
          description
            "MAC Limit Notify No Config";
        }
      }
      description
        "L2vpn bag mac limit notify";
    }

    typedef L2vpn-bag-mac-limit-action {
      type enumeration {
        enum "limit-none" {
          value 0;
          description
            "MAC Limit Action None";
        }
        enum "limit-flood" {
          value 1;
          description
            "MAC Limit Action Flood";
        }
        enum "limit-no-flood" {
          value 2;
          description
            "MAC Limit Action No Flood";
        }
        enum "limit-shutdown" {
          value 3;
          description
            "MAC Limit Action Shut";
        }
        enum "limit-no-config" {
          value 4;
          description
            "Mac Limit Action No Config";
        }
      }
      description
        "L2vpn bag mac limit action";
    }

    typedef L2vpn-msti-state {
      type enumeration {
        enum
          "msti-bag-stp-port-state-forwarding" {
          value 0;
          description
            "msti bag stp port state forwarding";
        }
        enum
          "msti-bag-stp-port-state-blocked" {
          value 1;
          description
            "msti bag stp port state blocked";
        }
        enum
          "msti-bag-stp-port-state-mac-learning" {
          value 2;
          description
            "msti bag stp port state mac learning";
        }
        enum "msti-bag-stp-port-state-nack" {
          value 3;
          description
            "msti bag stp port state nack";
        }
        enum
          "msti-bag-stp-port-state-forwarding-not-useful" {
          value 4;
          description
            "msti bag stp port state forwarding not useful";
        }
        enum
          "msti-bag-stp-port-state-blocked-not-useful" {
          value 5;
          description
            "msti bag stp port state blocked not useful";
        }
        enum
          "msti-bag-stp-port-state-mac-learning-not-useful" {
          value 6;
          description
            "msti bag stp port state mac learning not useful";
        }
        enum
          "msti-bag-erp-port-state-blocked-data-only" {
          value 7;
          description
            "msti bag erp port state blocked data only";
        }
        enum
          "msti-bag-erp-port-state-evpn-mcast-pe2ce-blocked" {
          value 8;
          description
            "msti bag erp port state evpn mcast pe2ce
           blocked";
        }
        enum
          "msti-bag-erp-port-state-evpn-port-state-mcast-blocked" {
          value 9;
          description
            "msti bag erp port state evpn port state mcast
           blocked";
        }
      }
      description "L2VPN MSTI state";
    }

    typedef L2vpn-ad-rt {
      type enumeration {
        enum "l2vpn-ad-rt-none" {
          value 0;
          description "Route target not set";
        }
        enum "l2vpn-ad-rt-as" {
          value 1;
          description
            "Route Target with 2 Byte AS number";
        }
        enum "l2vpn-ad-rt-4byte-as" {
          value 2;
          description
            "Route Target with 4 Byte AS number";
        }
        enum "l2vpn-ad-rt-v4-addr" {
          value 3;
          description
            "Route Target with IPv4 Address";
        }
        enum "es-import" {
          value 1538;
          description
            "Ethernet Segment Route Target from BGP";
        }
      }
      description "L2vpn ad rt";
    }

    typedef L2vpn-bag-ad-encap {
      type enumeration {
        enum
          "l2vpn-bag-ad-encap-not-specified" {
          value 0;
          description "Not Specified";
        }
        enum "l2vpn-bag-ad-encap-ether-vlan" {
          value 1;
          description "Ether VLAN";
        }
        enum "l2vpn-bag-ad-encap-ether" {
          value 2;
          description "Ethernet";
        }
      }
      description "L2VPN AD Encapsulation";
    }

    typedef L2vpn-xc-state {
      type enumeration {
        enum "l2vpn-xc-state-unresolved" {
          value 0;
          description "Unresolved";
        }
        enum "l2vpn-xc-state-down" {
          value 1;
          description "Down";
        }
        enum "l2vpn-xc-state-up" {
          value 2;
          description "Up";
        }
      }
      description "L2vpn xc state";
    }

    typedef Evpn-vpws-reason {
      type enumeration {
        enum "none" {
          value 0;
          description "No Issues";
        }
        enum "ac-down" {
          value 1;
          description "AC down";
        }
        enum "acparent-down" {
          value 2;
          description "AC parent down";
        }
        enum "no-remote-ead" {
          value 3;
          description "No remote EVI EAD";
        }
        enum "remote-ead-conflict" {
          value 4;
          description
            "Conflicting remote EADs";
        }
        enum "no-remote-esead" {
          value 5;
          description "No remote ES EAD";
        }
        enum "remote-unreachable" {
          value 6;
          description
            "Remote is not reachable";
        }
        enum "no-internal-id" {
          value 7;
          description "No internal ID";
        }
        enum "no-internal-label" {
          value 8;
          description "No internal label";
        }
        enum "waiting-path-resolution" {
          value 9;
          description
            "Waiting for path resolution";
        }
        enum "mtu-mismatch" {
          value 10;
          description "MTU mismatch";
        }
        enum "cw-mismatch" {
          value 11;
          description "CW mismatch";
        }
        enum "bad-remote-label" {
          value 12;
          description "Bad remote label";
        }
        enum "bad-remote-sid" {
          value 13;
          description "Bad remote SID";
        }
        enum "no-local-label" {
          value 14;
          description "No local MPLS label";
        }
        enum "no-local-sid" {
          value 15;
          description "No local SRv6 SID";
        }
        enum "srv6-not-enabled" {
          value 16;
          description
            "SRv6 is not enabled for EVPN";
        }
        enum "locator-not-resolved" {
          value 17;
          description
            "SRv6 locator not resolved";
        }
        enum "no-locator-config" {
          value 18;
          description
            "SRv6 locator not configured for this service";
        }
        enum "waiting-df-election" {
          value 19;
          description
            "Waiting DF election result";
        }
        enum "not-primary-df" {
          value 20;
          description "Not primary DF";
        }
        enum "no-pwhe-internal-label" {
          value 21;
          description
            "No PWHE internal label";
        }
        enum "evpn-vpws-reason-max" {
          value 22;
          description "evpn vpws reason max";
        }
      }
      description "Evpn vpws reason";
    }

    typedef L2vpn-p2mp-pw-ptree {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "rsvp-te" {
          value 1;
          description "RSVP TE";
        }
        enum "mldp" {
          value 2;
          description "MLDP";
        }
      }
      description "L2vpn p2mp pw ptree";
    }

    typedef L2vpn-pw-flow-label {
      type enumeration {
        enum "off" {
          value 0;
          description "Flow label is off";
        }
        enum "receive" {
          value 1;
          description
            "Flow label is enabled on the receive side";
        }
        enum "transmit" {
          value 2;
          description
            "Flow label is enabled on the transmit side";
        }
        enum "both" {
          value 3;
          description
            "Flow label is enabled on both transmit and
           receive sides";
        }
      }
      description
        "Pseudowire flow label load balance types";
    }

    typedef L2vpn-load-bal {
      type enumeration {
        enum "not-supported" {
          value 0;
          description
            "Load Balance Flow Not Supported";
        }
        enum "source-dest-mac" {
          value 1;
          description
            "Load Balance Flow src-dst-mac";
        }
        enum "source-dest-ip" {
          value 2;
          description
            "Load Balance Flow src-dst-ip";
        }
        enum "undefined" {
          value 3;
          description
            "Load Balance Flow Undefined";
        }
        enum "pseudowire-label" {
          value 4;
          description
            "Load Balance PW Label based";
        }
      }
      description "L2vpn load bal";
    }

    typedef L2vpn-prefpath-option {
      type enumeration {
        enum
          "l2vpn-pw-mpls-pref-path-not-specified" {
          value 0;
          description "Not Secified";
        }
        enum
          "l2vpn-pw-mpls-pref-path-next-hop-ip" {
          value 1;
          description "Next Hop IP";
        }
        enum
          "l2vpn-pw-mpls-pref-path-te-tunnel" {
          value 2;
          description "TE Tunnel";
        }
        enum
          "l2vpn-pw-mpls-pref-path-ip-tunnel" {
          value 3;
          description "IP Tunnel";
        }
        enum
          "l2vpn-pw-mpls-pref-path-tp-tunnel" {
          value 4;
          description "TP Tunnel";
        }
        enum "l2vpn-pw-mpls-pref-path-sr-te" {
          value 5;
          description "SR TE Policy";
        }
        enum
          "l2vpn-pw-mpls-pref-path-te-named-tunnel" {
          value 8;
          description "Named TE Tunnel";
        }
      }
      description "Preferred Path Option";
    }

    typedef L2vpn-pw {
      type enumeration {
        enum "l2vpn-pw-type-unknown" {
          value 0;
          description "Unknown";
        }
        enum
          "l2vpn-pw-type-frame-relay-dlci" {
          value 1;
          description "Frame Relay DLCI";
        }
        enum "l2vpn-pw-type-atm-aal5-sdu" {
          value 2;
          description
            "ATM AAL5 SDU VCC transport";
        }
        enum "l2vpn-pw-type-atm-trans-cell" {
          value 3;
          description
            "ATM transparent cell transport";
        }
        enum "l2vpn-pw-type-ether-vlan" {
          value 4;
          description
            "Ethernet VLAN tagged mode ";
        }
        enum "l2vpn-pw-type-ether" {
          value 5;
          description "Ethernet";
        }
        enum "l2vpn-pw-type-hdlc" {
          value 6;
          description "HDLC";
        }
        enum "l2vpn-pw-type-ppp" {
          value 7;
          description "PPP";
        }
        enum "l2vpn-pw-type-sonet-over-mpls" {
          value 8;
          description
            "SONET/SDH Circuit Emulation Service Over MPLS
           (CEM)";
        }
        enum "l2vpn-pw-type-atm-n-vcc-cell" {
          value 9;
          description
            "ATM n-to-one VCC cell transport";
        }
        enum "l2vpn-pw-type-atm-n-vpc-cell" {
          value 10;
          description
            "ATM n-to-one VPC cell transport";
        }
        enum "l2vpn-pw-type-ip" {
          value 11;
          description "IP Layer2 Transport";
        }
        enum "l2vpn-pw-type-atm-vcc-cell" {
          value 12;
          description
            "ATM one-to-one VCC cell transport";
        }
        enum "l2vpn-pw-type-atm-vpc-cell" {
          value 13;
          description
            "ATM one-to-one VPC cell transport";
        }
        enum "l2vpn-pw-type-atm-aal5-pdu" {
          value 14;
          description
            "ATM AAL5 PDU VCC transport";
        }
        enum "l2vpn-pw-type-frame-relay" {
          value 15;
          description
            "Frame Relay port mode";
        }
        enum "l2vpn-pw-type-sonet" {
          value 16;
          description "SONET/SDH Circuit";
        }
        enum "l2vpn-pw-type-vpls" {
          value 17;
          description "VPLS";
        }
        enum "l2vpn-pw-type-tdm-sa-to-p-e1" {
          value 18;
          description "TDM E1";
        }
        enum "l2vpn-pw-type-tdm-sa-to-p-t1" {
          value 19;
          description "TDM T1";
        }
        enum "l2vpn-pw-type-tdm-sa-to-p-e3" {
          value 20;
          description "TDM E3";
        }
        enum "l2vpn-pw-type-tdm-sa-to-p-t3" {
          value 21;
          description "TDM T3";
        }
        enum "l2vpn-pw-type-tdm-ce-so-psn" {
          value 22;
          description "TDM CES over PSN";
        }
      }
      description "L2vpn pw";
    }

    typedef L2vpn-pw-control-word {
      type enumeration {
        enum "l2vpn-pw-control-word-unknown" {
          value 0;
          description "Unknown";
        }
        enum "l2vpn-pw-control-word-clear" {
          value 1;
          description "Clear";
        }
        enum "l2vpn-pw-control-word-set" {
          value 2;
          description "Set";
        }
        enum
          "l2vpn-pw-control-word-mandatory" {
          value 3;
          description "Mandatory";
        }
      }
      description "L2vpn pw control word";
    }

    typedef Evpn-bag-path-issues {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown Issue";
        }
        enum "invalid-transport-id" {
          value 1;
          description "Invalid Transport ID";
        }
        enum "sid-format-mismatch" {
          value 2;
          description
            "SIDs Do Not Match Local Format";
        }
        enum "control-word-mismatch" {
          value 3;
          description
            "Control Word Mismatch";
        }
        enum "mtu-mismatch" {
          value 4;
          description "MTU Mismatch";
        }
      }
      description "Evpn bag path issues";
    }

    typedef Evpn-bag-l2-attr-cw {
      type enumeration {
        enum "unspecified" {
          value 0;
          description
            "Control Word Not Specified";
        }
        enum "disabled" {
          value 1;
          description
            "Control Word Disabled";
        }
        enum "enabled" {
          value 2;
          description "Control Word Enabled";
        }
      }
      description "Evpn bag l2 attr cw";
    }

    typedef Evpn-bag-df-role {
      type enumeration {
        enum "invalid" {
          value 0;
          description
            "Designated Forwarder Role Not Specified";
        }
        enum "primary" {
          value 1;
          description
            "Designated Forwarder Role Primary";
        }
        enum "backup" {
          value 2;
          description
            "Designated Forwarder Role Backup";
        }
        enum "not-designated-forwarder" {
          value 3;
          description
            "No Designated Forwarder Role";
        }
      }
      description "Evpn bag df role";
    }

    typedef Mgmt-srv6-endpoint {
      type enumeration {
        enum "unknown" {
          value 0;
          description
            "Unknown Endpoint type";
        }
        enum "end" {
          value 1;
          description "End (no PSP/USP)";
        }
        enum "end-with-psp" {
          value 2;
          description "End with PSP";
        }
        enum "end-with-usp" {
          value 3;
          description "End with USP";
        }
        enum "end-with-psp-usp" {
          value 4;
          description "End with PSP/USP";
        }
        enum "end-x" {
          value 5;
          description "End.X (no PSP/USP)";
        }
        enum "end-x-with-psp" {
          value 6;
          description "End.X with PSP";
        }
        enum "end-x-with-usp" {
          value 7;
          description "End.X with USP";
        }
        enum "end-x-with-psp-usp" {
          value 8;
          description "End.X with PSP/USP";
        }
        enum "end-tbl" {
          value 9;
          description "End.T (no PSP/USP)";
        }
        enum "end-tbl-with-psp" {
          value 10;
          description "End.T with PSP";
        }
        enum "end-tbl-with-usp" {
          value 11;
          description "End.T with USP";
        }
        enum "end-tbl-with-psp-usp" {
          value 12;
          description "End.T with PSP/USP";
        }
        enum "end-b6-insert" {
          value 13;
          description "End.B6.Insert";
        }
        enum "end-b6-encaps" {
          value 14;
          description "End.B6.Encaps";
        }
        enum "end-bm" {
          value 15;
          description "End.BM";
        }
        enum "end-dx6" {
          value 16;
          description "End.DX6";
        }
        enum "end-dx4" {
          value 17;
          description "End.DX4";
        }
        enum "end-dt6" {
          value 18;
          description "End.DT6";
        }
        enum "end-dt4" {
          value 19;
          description "End.DT4";
        }
        enum "end-dt46" {
          value 20;
          description "End.DT46";
        }
        enum "end-dx2" {
          value 21;
          description "End.DX2";
        }
        enum "end-dx2v" {
          value 22;
          description "End.DX2V";
        }
        enum "end-dt2u" {
          value 23;
          description "End.DT2U";
        }
        enum "end-dt2m" {
          value 24;
          description "End.DT2M";
        }
        enum "end-s" {
          value 25;
          description "End.S";
        }
        enum "end-b6-insert-red" {
          value 26;
          description
            "End.B6.Insert.Reduced";
        }
        enum "end-b6-encaps-red" {
          value 27;
          description
            "End.B6.Encaps.Reduced";
        }
        enum "end-with-usd" {
          value 28;
          description "End with USD";
        }
        enum "end-with-psp-usd" {
          value 29;
          description "End with PSP/USD";
        }
        enum "end-with-usp-usd" {
          value 30;
          description "End with USP/USD";
        }
        enum "end-with-psp-usp-usd" {
          value 31;
          description "End with PSP/USP/USD";
        }
        enum "end-x-with-usd" {
          value 32;
          description "End.X with USD";
        }
        enum "end-x-with-psp-usd" {
          value 33;
          description "End.X with PSP/USD";
        }
        enum "end-x-with-usp-usd" {
          value 34;
          description "End.X with USP/USD";
        }
        enum "end-x-with-psp-usp-usd" {
          value 35;
          description
            "End.X with PSP/USP/USD";
        }
        enum "end-tbl-with-usd" {
          value 36;
          description "End.T with USD";
        }
        enum "end-tbl-with-psp-usd" {
          value 37;
          description "End.T with PSP/USD";
        }
        enum "end-tbl-with-usp-usd" {
          value 38;
          description "End.T with USP/USD";
        }
        enum "end-tbl-with-psp-usp-usd" {
          value 39;
          description
            "End.T with PSP/USP/USD";
        }
        enum "end-op" {
          value 40;
          description "End.OP";
        }
        enum "end-otp" {
          value 41;
          description "End.OTP";
        }
        enum "un-shift-only" {
          value 42;
          description "uN Shift-only";
        }
        enum "un" {
          value 43;
          description "uN";
        }
        enum "un-psp" {
          value 44;
          description "uN with PSP";
        }
        enum "un-usp" {
          value 45;
          description "uN with USP";
        }
        enum "un-psp-usp" {
          value 46;
          description "uN with PSP-USP";
        }
        enum "un-usd" {
          value 47;
          description "uN with USD";
        }
        enum "un-psp-usd" {
          value 48;
          description "uN with PSP-USD";
        }
        enum "un-usp-usd" {
          value 49;
          description "uN with USP-USD";
        }
        enum "un-psp-usp-usd" {
          value 50;
          description "uN with PSP_USP-USD";
        }
        enum "ua-shift-only" {
          value 51;
          description "uA Shift-only";
        }
        enum "ua" {
          value 52;
          description "uA";
        }
        enum "ua-psp" {
          value 53;
          description "uA with PSP";
        }
        enum "ua-usp" {
          value 54;
          description "uA with USP";
        }
        enum "ua-psp-usp" {
          value 55;
          description "uA with PSP-USP";
        }
        enum "ua-usd" {
          value 56;
          description "uA with USD";
        }
        enum "ua-psp-usd" {
          value 57;
          description "uA with PSP-USD";
        }
        enum "ua-usp-usd" {
          value 58;
          description "uA with USP-USD";
        }
        enum "ua-psp-usp-usd" {
          value 59;
          description "uA with PSP_USP-USD";
        }
        enum "udx6" {
          value 60;
          description "uDX6";
        }
        enum "udx4" {
          value 61;
          description "uDX4";
        }
        enum "udt6" {
          value 62;
          description "uDT6";
        }
        enum "udt4" {
          value 63;
          description "uDT4";
        }
        enum "udt46" {
          value 64;
          description "uDT46";
        }
        enum "udx2" {
          value 65;
          description "uDX2";
        }
        enum "udx2v" {
          value 66;
          description "uDX2V";
        }
        enum "udt2u" {
          value 67;
          description "uDT2U";
        }
        enum "udt2m" {
          value 68;
          description "uDT2M";
        }
        enum "ub6-insert" {
          value 69;
          description "uB6 Insert";
        }
        enum "ub6-encaps" {
          value 70;
          description "uB6 Encaps";
        }
        enum "ub6-insert-red" {
          value 71;
          description "uB6 Insert.Red";
        }
        enum "ub6-encaps-red" {
          value 72;
          description "uB6 Encaps.Red";
        }
        enum "ubm" {
          value 73;
          description "uBM";
        }
      }
      description
        "SRv6 Endpoint Behavior Type";
    }

    typedef Mgmt-srv6-headend {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "transit" {
          value 1;
          description "T (Pure transit)";
        }
        enum "h-insert" {
          value 2;
          description "H.Insert";
        }
        enum "h-insert-red" {
          value 3;
          description "H.Insert.Red";
        }
        enum "h-encaps" {
          value 4;
          description "H.Encaps";
        }
        enum "h-encaps-red" {
          value 5;
          description "H.Encaps.Red";
        }
        enum "h-encaps-l2" {
          value 6;
          description "H.Encaps.L2";
        }
        enum "h-encaps-l2-red" {
          value 7;
          description "H.Encaps.L2.Red";
        }
      }
      description
        "SRv6 Headend Behavior Type";
    }

    typedef L2vpn-l2tp-tunnel-state {
      type enumeration {
        enum "l2vpn-l2tp-idle" {
          value 0;
          description "Idle";
        }
        enum
          "l2vpn-l2tp-wait-for-connecting" {
          value 1;
          description "Wait for connecting";
        }
        enum "l2vpn-l2tp-wait-for-connected" {
          value 2;
          description "Wait for connected";
        }
        enum "l2vpn-l2tp-in-coming-call" {
          value 3;
          description "Incoming call";
        }
        enum "l2vpn-l2tp-connected" {
          value 4;
          description "Connected";
        }
        enum "l2vpn-l2tp-disconnected" {
          value 5;
          description "Disconnected";
        }
      }
      description "L2vpn l2tp tunnel state";
    }

    typedef L2vpn-tos-mode {
      type enumeration {
        enum "l2vpn-pw-ip-tos-none" {
          value 0;
          description "None";
        }
        enum "l2vpn-pw-ip-tos-reflect" {
          value 1;
          description "Reflect the TOS";
        }
      }
      description "L2vpn tos mode";
    }

    typedef L2vpn-encap-method {
      type enumeration {
        enum "l2vpn-pw-encaps-not-specified" {
          value 0;
          description "Not Specified";
        }
        enum "l2vpn-pw-encaps-l2tpv3" {
          value 1;
          description "L2TPv3 encapsulation";
        }
        enum "l2vpn-pw-encaps-l2tpv2" {
          value 2;
          description "L2TPv2 encapsulation";
        }
        enum "l2vpn-pw-encaps-mpls" {
          value 3;
          description "MPLS encapsulation";
        }
        enum "l2vpn-pw-encaps-srv6" {
          value 4;
          description "SRv6 encapsulation";
        }
        enum "l2vpn-pw-encaps-unknown" {
          value 5;
          description "Unknown";
        }
      }
      description "Encapsulation Method";
    }

    typedef L2vpn-pw-sequence {
      type enumeration {
        enum "l2vpn-pw-sequence-off" {
          value 0;
          description "Sequencing is Off";
        }
        enum "l2vpn-pw-sequence-xmit" {
          value 1;
          description
            "Sequencing on the transmit side";
        }
        enum "l2vpn-pw-sequence-recv" {
          value 2;
          description
            "Sequencing on the receive side";
        }
        enum "l2vpn-pw-sequence-trans" {
          value 3;
          description
            "Sequencing is transparent";
        }
        enum "l2vpn-pw-sequence-both" {
          value 4;
          description
            "Sequencing on both sides";
        }
      }
      description "L2vpn pw sequence";
    }

    typedef L2vpn-signalling-proto {
      type enumeration {
        enum "l2vpn-pw-sig-not-specified" {
          value 0;
          description "Not specified";
        }
        enum "l2vpn-pw-sig-none" {
          value 1;
          description "Static";
        }
        enum "l2vpn-pw-sig-l2tpv3" {
          value 2;
          description "L2TPv3 signaling";
        }
        enum "l2vpn-pw-sig-l2tpv2" {
          value 3;
          description "L2TPv2 signaling";
        }
        enum "l2vpn-pw-sig-ldp" {
          value 4;
          description "LDP";
        }
        enum "l2vpn-pw-sig-bgp" {
          value 5;
          description "BGP";
        }
      }
      description "L2vpn signalling proto";
    }

    typedef L2vpn-pw-state {
      type enumeration {
        enum "l2vpn-pw-state-unresolved" {
          value 0;
          description "Unresolved";
        }
        enum "l2vpn-pw-state-idle" {
          value 1;
          description "Idle";
        }
        enum "l2vpn-pw-state-provisioned" {
          value 2;
          description "Provisioned";
        }
        enum "l2vpn-pw-state-remote-standby" {
          value 3;
          description "Remote standby";
        }
        enum "l2vpn-pw-state-local-ready" {
          value 4;
          description "Local ready";
        }
        enum "l2vpn-pw-state-all-ready" {
          value 5;
          description "All ready";
        }
        enum "l2vpn-pw-state-established" {
          value 6;
          description "Established";
        }
      }
      description "L2vpn pw state";
    }

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

    typedef L2vpn-peer {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "ipv4" {
          value 1;
          description "IPv4";
        }
        enum "ipv6" {
          value 2;
          description "IPv6";
        }
        enum "internal-label" {
          value 3;
          description "Internal Label";
        }
        enum "internal-id" {
          value 4;
          description "Internal ID";
        }
      }
      description "L2vpn peer";
    }

    typedef L2vpn-protection-role {
      type enumeration {
        enum "l2vpn-protection-primary" {
          value 0;
          description
            "Segment configured as primary";
        }
        enum "l2vpn-protection-backup" {
          value 1;
          description
            "Segment configured as backup";
        }
      }
      description
        "L2VPN Configurable protection roles";
    }

    typedef L2vpn-protection {
      type enumeration {
        enum "l2vpn-protection-unknown" {
          value 0;
          description
            "Unknown type of protection";
        }
        enum "l2vpn-protection-interface" {
          value 1;
          description
            "Interface protection type";
        }
        enum "l2vpn-protection-pseudowire" {
          value 2;
          description "PW protection type";
        }
        enum "l2vpn-protection-group" {
          value 3;
          description
            "Group protection type ";
        }
      }
      description "L2VPN Protection types";
    }

    typedef L2vpn-rg-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Not defined";
        }
        enum "active" {
          value 1;
          description "Active";
        }
        enum "standby" {
          value 2;
          description "Standby";
        }
      }
      description "L2vpn rg state";
    }

    typedef L2vpn-interworking {
      type enumeration {
        enum "l2vpn-iw-type-none" {
          value 0;
          description "None";
        }
        enum "l2vpn-iw-type-ethernet" {
          value 1;
          description "Ethernet";
        }
        enum "l2vpn-iw-type-ppp" {
          value 2;
          description "PPP";
        }
        enum "l2vpn-iw-type-ipv4" {
          value 3;
          description "IPv4";
        }
        enum "l2vpn-iw-type-voluntary" {
          value 4;
          description "Voluntary";
        }
        enum "l2vpn-iw-type-frf8" {
          value 5;
          description "FRF8";
        }
      }
      description "L2vpn interworking";
    }

    typedef L2vpn-segment-state {
      type enumeration {
        enum
          "l2vpn-segment-state-unresolved" {
          value 0;
          description "Unresolved";
        }
        enum "l2vpn-segment-state-up" {
          value 1;
          description "Up";
        }
        enum "l2vpn-segment-state-down" {
          value 2;
          description "Down";
        }
        enum
          "l2vpn-segment-state-admin-down" {
          value 3;
          description "Admin down";
        }
        enum "l2vpn-segment-state-local-up" {
          value 4;
          description "Local up";
        }
        enum "l2vpn-segment-state-remote-up" {
          value 5;
          description "Remote up";
        }
        enum "l2vpn-segment-state-connected" {
          value 6;
          description "Connected";
        }
        enum "l2vpn-segment-state-standby" {
          value 7;
          description "Standby";
        }
        enum
          "l2vpn-segment-state-standby-ready" {
          value 8;
          description "Standby Ready";
        }
        enum
          "l2vpn-segment-state-standby-inactive" {
          value 9;
          description "Standby Inactive";
        }
      }
      description "L2vpn segment state";
    }

    typedef L2vpn-fr-mode {
      type enumeration {
        enum "l2vpn-fr-port-mode" {
          value 0;
          description
            "Frame Relay port mode";
        }
        enum "l2vpn-fr-dlci-mode" {
          value 1;
          description
            "Frame Relay DLCI mode";
        }
      }
      description "L2vpn fr mode";
    }

    typedef L2vpn-atm-mode {
      type enumeration {
        enum "l2vpn-atm-port-mode" {
          value 0;
          description "ATM port mode";
        }
        enum "l2vpn-atm-vp-mode" {
          value 1;
          description
            "ATM Virtual Path mode";
        }
        enum "l2vpn-atm-vc-mode" {
          value 2;
          description
            "ATM Virtual Channel mode";
        }
      }
      description "L2vpn atm mode";
    }

    typedef L2vpn-time-stamp-mode {
      type enumeration {
        enum "unknown" {
          value 0;
          description
            "Unknown time stamp mode";
        }
        enum "differential" {
          value 1;
          description
            "Differential time stamp mode";
        }
        enum "absolute" {
          value 2;
          description
            "Absolute Time Stamp mode";
        }
        enum "none" {
          value 3;
          description "time stamp mode none";
        }
      }
      description
        "L2VPN TDM Time stamp modes";
    }

    typedef L2vpn-tdm-rtp-option {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown RTP option";
        }
        enum "present" {
          value 1;
          description "RTP option present";
        }
        enum "absent" {
          value 2;
          description "RTP option absent";
        }
      }
      description "L2VPN TDM RTP option";
    }

    typedef L2vpn-tdm-mode {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown mode";
        }
        enum "ce-so-psn" {
          value 1;
          description "CESoPSN mode";
        }
        enum "sa-to-p-e1" {
          value 2;
          description "SAToP E1 mode";
        }
        enum "sa-to-p-t1" {
          value 3;
          description "SAToP T1 mode";
        }
        enum "sa-to-p-e3" {
          value 4;
          description "SAToP E3 mode";
        }
        enum "sa-to-p-t3" {
          value 5;
          description "SAToP T3 mode";
        }
      }
      description "L2VPN TDM modes";
    }

    typedef L2vpn-interface {
      type enumeration {
        enum "l2vpn-intf-type-unknown" {
          value 0;
          description "Unknown";
        }
        enum "l2vpn-intf-type-ethernet" {
          value 1;
          description "Ethernet";
        }
        enum "l2vpn-intf-type-vlan" {
          value 2;
          description "Ethernet Vlan";
        }
        enum "l2vpn-intf-type-atm" {
          value 3;
          description "ATM";
        }
        enum "l2vpn-intf-type-frame-relay" {
          value 4;
          description "Frame Relay";
        }
        enum "l2vpn-intf-type-hdlc" {
          value 5;
          description "HDLC";
        }
        enum "l2vpn-intf-type-ppp" {
          value 6;
          description "PPP";
        }
        enum "l2vpn-intf-type-span" {
          value 7;
          description "SPAN";
        }
        enum "l2vpn-intf-type-bvi" {
          value 8;
          description "BVI";
        }
        enum "l2vpn-intf-type-cem" {
          value 9;
          description "CEM";
        }
        enum "l2vpn-intf-type-pw-ether" {
          value 10;
          description "PsuedowireEther";
        }
        enum "l2vpn-intf-type-pw-iw" {
          value 11;
          description "PsuedowireIW";
        }
        enum "l2vpn-intf-type-vni" {
          value 12;
          description "VXLAN";
        }
      }
      description "L2vpn interface";
    }

    typedef L2vpn-segment {
      type enumeration {
        enum "l2vpn-segment-type-unresolved" {
          value 0;
          description "Unresolved segment";
        }
        enum "l2vpn-segment-type-ac" {
          value 1;
          description
            "Attachment circuit segment";
        }
        enum "l2vpn-segment-type-pw" {
          value 2;
          description "Pseudowire segment";
        }
        enum "l2vpn-segment-type-bd-ac" {
          value 3;
          description
            "Bridge domain attachment circuit";
        }
        enum "l2vpn-segment-type-vfi" {
          value 4;
          description
            "Virtual forwarding instance segment";
        }
        enum "l2vpn-segment-type-bd-pw" {
          value 5;
          description "Bridge Pseudowire";
        }
        enum "l2vpn-segment-type-bd-pbb" {
          value 6;
          description
            "Bridge domain PBB segment";
        }
        enum "l2vpn-segment-type-bd-evpn" {
          value 7;
          description
            "Bridge domain EVPN segment";
        }
        enum "l2vpn-segment-type-vni" {
          value 8;
          description
            "VxLAN Network Identifier (VNI) segment";
        }
      }
      description "L2vpn segment";
    }

    typedef L2vpn-ad-rd {
      type enumeration {
        enum "l2vpn-ad-rd-none" {
          value 0;
          description
            "Route Distinguisher not set";
        }
        enum "l2vpn-ad-rd-auto" {
          value 1;
          description
            "Route Distinguisher auto-generated";
        }
        enum "l2vpn-ad-rd-as" {
          value 2;
          description
            "Route Distinguisher with 2 Byte AS number";
        }
        enum "l2vpn-ad-rd-4byte-as" {
          value 3;
          description
            "Route Distinguisher with 4 Byte AS number";
        }
        enum "l2vpn-ad-rd-v4-addr" {
          value 4;
          description
            "Route Distinguisher with IPv4 Address";
        }
      }
      description "L2vpn ad rd";
    }

    typedef L2vpn-pw-fec {
      type enumeration {
        enum "l2vpn-pw-fec-128" {
          value 0;
          description
            "FEC 128 pseudowire type";
        }
        enum "l2vpn-pw-fec-129" {
          value 1;
          description
            "FEC 129 pseudowire type";
        }
        enum "l2vpn-pw-fec-not-applicable" {
          value 268435455;
          description "FEC Not Applicable";
        }
      }
      description "L2vpn pw fec";
    }

    typedef L2vpn-pw-id {
      type enumeration {
        enum "l2vpn-pw-id-type-manual" {
          value 1;
          description "Manual";
        }
        enum "l2vpn-pw-id-type-ad-vpls" {
          value 2;
          description "AD VPLS";
        }
        enum "l2vpn-pw-id-type-ad-vpws" {
          value 3;
          description "AD VPWS";
        }
        enum "l2vpn-pw-id-type-ad-vpls-ldp" {
          value 4;
          description "AD VPLS-LDP";
        }
        enum "l2vpn-pw-id-type-pwr" {
          value 5;
          description "PWR";
        }
        enum "l2vpn-pw-id-type-evpn" {
          value 6;
          description "EVPN";
        }
      }
      description "L2vpn pw id";
    }

    typedef L2vpn-preferred {
      type enumeration {
        enum "te-tunnel" {
          value 0;
          description "TE Tunnel";
        }
        enum "ip-tunnel" {
          value 1;
          description "IP Tunnel";
        }
        enum "tp-tunnel" {
          value 2;
          description "TP Tunnel";
        }
        enum "mte-tunnel" {
          value 3;
          description "mTE";
        }
        enum "mldp-tunnel" {
          value 4;
          description "mLDP";
        }
        enum "sr-te-policy" {
          value 5;
          description "SR TE Policy";
        }
        enum "te-named-tunnel" {
          value 8;
          description "Named TE Tunnel";
        }
      }
      description "Preferred Type";
    }

    typedef L2vpn-ha-nsr-not-ready-reason {
      type enumeration {
        enum "collab-time-out" {
          value 0;
          description
            "Collaborator connection time out";
        }
        enum "collab-conntection-idt" {
          value 1;
          description
            "Collaborator connection down or IDT not done";
        }
        enum "nsr-peer-not-connected" {
          value 2;
          description
            "NSR peer not connected";
        }
        enum "nsr-peer-not-in-sync" {
          value 3;
          description "NSR peer not in sync";
        }
      }
      description
        "L2vpn ha nsr not ready reason";
    }

    typedef L2vpn-sync-status {
      type enumeration {
        enum "not-ready" {
          value 0;
          description "Not Ready";
        }
        enum "ready" {
          value 1;
          description "Ready";
        }
      }
      description "L2vpn sync status";
    }

    typedef L2vpn-id-mgr-app-bag {
      type enumeration {
        enum
          "l2vpn-id-mgr-app-bag-type-virtual-ac" {
          value 0;
          description "Virtual AC";
        }
        enum "l2vpn-id-mgr-app-bag-type-ac" {
          value 1;
          description "AC";
        }
        enum "l2vpn-id-mgr-app-bag-type-pw" {
          value 2;
          description "PW";
        }
        enum "l2vpn-id-mgr-app-bag-type-bd" {
          value 3;
          description "BD";
        }
        enum "l2vpn-id-mgr-app-bag-type-fxc" {
          value 4;
          description "FXC";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-mp2mp" {
          value 5;
          description "MP2MP";
        }
        enum "l2vpn-id-mgr-app-bag-type-rd" {
          value 6;
          description "RD";
        }
        enum "l2vpn-id-mgr-app-bag-type-pbb" {
          value 7;
          description "PBB";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-if-list" {
          value 8;
          description "IFLIST";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-atom" {
          value 9;
          description "ATOM";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-global" {
          value 10;
          description "GLOBAL";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-pw-group" {
          value 11;
          description "PWGROUP";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-evpn" {
          value 12;
          description "EVPN";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-evpn-lbl" {
          value 13;
          description "EVPN LBL";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-evpn-rd" {
          value 14;
          description "EVPN RD";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-ital" {
          value 15;
          description "ITAL";
        }
        enum "l2vpn-id-mgr-app-bag-type-bp" {
          value 16;
          description "BP";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-evpn-tep" {
          value 17;
          description "EVPN TEP";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-evpn-es" {
          value 18;
          description "EVPN ES";
        }
        enum
          "l2vpn-id-mgr-app-bag-type-count" {
          value 19;
          description "Count/Invalid";
        }
      }
      description
        "L2VPN ID Manager App Type";
    }

    typedef Iccp-sm-port-state {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "unconfigured" {
          value 1;
          description "Unconfigured";
        }
        enum "unsynchronized" {
          value 2;
          description "Unsynchronized";
        }
        enum "operational" {
          value 3;
          description "Operational";
        }
        enum "failed" {
          value 4;
          description "Failed";
        }
        enum "reverting" {
          value 5;
          description "Reverting";
        }
      }
      description
        "ICCP-based service multi-homing port state";
    }

    typedef Iccp-sm-state {
      type enumeration {
        enum "unresolved" {
          value 0;
          description "Unresolved";
        }
        enum "provisioned" {
          value 1;
          description "Provisioned";
        }
        enum "connecting" {
          value 2;
          description "Connecting";
        }
        enum "connected" {
          value 3;
          description "Connected";
        }
        enum "synchronizing" {
          value 4;
          description "Synchronizing";
        }
        enum "synchronized" {
          value 5;
          description "Synchronized";
        }
      }
      description
        "ICCP-based service multi-homing group state";
    }

    typedef L2vpn-main-if-protect {
      type enumeration {
        enum "not-protected" {
          value 0;
          description "Not Protected";
        }
        enum "mstp-protected" {
          value 1;
          description "MSTP Protected";
        }
        enum "erp-protected" {
          value 2;
          description "ERP Protected";
        }
        enum "pmclag-protected" {
          value 3;
          description "PMCLAG Protected";
        }
      }
      description "L2vpn main if protect";
    }

    typedef L2vpn-main-if-instance-state {
      type enumeration {
        enum "forwarding" {
          value 0;
          description "Forwarding state";
        }
        enum "blocked" {
          value 1;
          description "Blocked state";
        }
        enum "mac-learning" {
          value 2;
          description "Mac learning state";
        }
        enum "nack" {
          value 3;
          description "Nack state";
        }
        enum "forwarning-not-useful" {
          value 4;
          description
            "Forwarding not useful state";
        }
        enum "blocked-not-useful" {
          value 5;
          description
            "Blocked not useful state";
        }
        enum "mac-learning-not-useful" {
          value 6;
          description
            "Mac Learning not useful state";
        }
        enum "blocked-data-only" {
          value 7;
          description
            "Blocked data only state";
        }
        enum "mcast-pe2-ce-blocked" {
          value 8;
          description
            "Mcast PE to CE blocked state";
        }
        enum "port-state-unknown" {
          value 9;
          description "Port state unknown";
        }
      }
      description
        "State of a main port instance";
    }

    typedef L2vpn-ad-vpls-id {
      type enumeration {
        enum "l2vpn-ad-vpls-id-none" {
          value 0;
          description "VPLS-ID not set";
        }
        enum "l2vpn-ad-vpls-id-auto" {
          value 1;
          description
            "Auto generated VPLS-ID";
        }
        enum "l2vpn-ad-vpls-id-as" {
          value 10;
          description
            "VPLS-ID with 2 Byte AS number";
        }
        enum "l2vpn-ad-vpls-id-v4-addr" {
          value 266;
          description
            "VPLS-ID with IPv4 Address";
        }
      }
      description "L2vpn ad vpls id";
    }

    typedef L2vpn-ad-lsd-err {
      type enumeration {
        enum "l2vpn-ad-lsd-err-type-none" {
          value 0;
          description "No Error";
        }
        enum
          "l2vpn-ad-lsd-err-type-rw-create-abort-lbl-alloc" {
          value 1;
          description
            "RW Creation aborted due to related Lbl Alloc
           failure";
        }
        enum
          "l2vpn-ad-lsd-err-type-lbl-alloc-abort-rw-create" {
          value 2;
          description
            "Lbl Alloc disallowed due to related RW Creation
           failure";
        }
        enum
          "l2vpn-ad-lsd-err-type-lbl-alloc-abort-lbl-alloc" {
          value 3;
          description
            "Lbl Alloc disallowed due to related Lbl Alloc
           failure";
        }
        enum
          "l2vpn-ad-lsd-err-type-lbl-alloc-lbl-ctx-mismatch" {
          value 4;
          description "Lbl Ctx mismatch";
        }
        enum
          "l2vpn-ad-lsd-err-type-rw-create-fpi-size-mismatch" {
          value 5;
          description "FPI Size mismatch";
        }
        enum
          "l2vpn-ad-lsd-err-type-rw-create-fpi-version-mismatch" {
          value 6;
          description "FPI Version mismatch";
        }
        enum "l2vpn-ad-lsd-err-type-enospc" {
          value 7;
          description "Out of Label";
        }
        enum "l2vpn-ad-lsd-err-type-enomem" {
          value 8;
          description "No Memory";
        }
        enum
          "l2vpn-ad-lsd-err-type-undefined" {
          value 9;
          description "LABEL ERR";
        }
      }
      description "L2vpn ad lsd err";
    }

    typedef L2vpn-ad-sig-method {
      type enumeration {
        enum "l2vpn-ad-sig-method-none" {
          value 0;
          description "None";
        }
        enum "l2vpn-ad-sig-method-bgp" {
          value 1;
          description "BGP";
        }
        enum "l2vpn-ad-sig-method-ldp" {
          value 2;
          description "LDP";
        }
      }
      description "L2vpn ad sig method";
    }

    typedef Evpn-vpws {
      type enumeration {
        enum "vlan-unaware" {
          value 0;
          description "VlanUnaware";
        }
        enum "vlan-aware" {
          value 1;
          description "VlanAware";
        }
      }
      description "EVPN VU/VA Types";
    }

    grouping L2VPN-XC-BRIEF-LINE {
      description "L2VPN XC BRIEF LINE";
      leaf psn-type {
        type L2vpn-brief-psn;
        description "PSN Type";
      }

      leaf ac1-encapsulation {
        type L2vpn-ac-encap;
        description "AC1 encapsulation";
      }

      leaf ac2-encapsulation {
        type L2vpn-ac-encap;
        description "AC2 encapsulation";
      }

      list up-count {
        max-elements 4;
        description
          "Number of active cross-connections array -
         
         Index 0 is LikeToLike, 1 is IPInterworking, 2 is
         
         EthernetInterworking, 3 is Total";
        leaf entry {
          type uint32;
          description
            "Number of active cross-connections array -
           
           Index 0 is LikeToLike, 1 is IPInterworking, 2 is
           
           EthernetInterworking, 3 is Total";
        }
      }  // list up-count

      list down-count {
        max-elements 4;
        description
          "Number of non-active cross-connections array -
         
         Index 0 is LikeToLike, 1 is IPInterworking, 2 is
         
         EthernetInterworking, 3 is Total";
        leaf entry {
          type uint32;
          description
            "Number of non-active cross-connections array -
           
           Index 0 is LikeToLike, 1 is IPInterworking, 2 is
           
           EthernetInterworking, 3 is Total";
        }
      }  // list down-count

      list unresolved-count {
        max-elements 4;
        description
          "Number of unresolved cross-connections array -
         
         Index 0 is LikeToLike, 1 is IPInterworking, 2 is
         
         EthernetInterworking, 3 is Total";
        leaf entry {
          type uint32;
          description
            "Number of unresolved cross-connections array -
           
           Index 0 is LikeToLike, 1 is IPInterworking, 2 is
           
           EthernetInterworking, 3 is Total";
        }
      }  // list unresolved-count
    }  // grouping L2VPN-XC-BRIEF-LINE

    grouping L2VPN-XC-BRIEF-FIRST-LAYER {
      description
        "L2VPN XC BRIEF FIRST LAYER";
      list ac2 {
        description
          "Array of l2vpn_xc_brief_line indexed by the AC2
         encapsulation type plus one type for PW";
        uses L2VPN-XC-BRIEF-LINE;
      }  // list ac2
    }  // grouping L2VPN-XC-BRIEF-FIRST-LAYER

    grouping L2VPN-XC-BRIEF-MATRIX {
      description "L2VPN XC BRIEF MATRIX";
      list ac1 {
        description
          "Array of l2vpn_xc_brief_first layer indexed by
         the AC1 encapsulation type";
        uses L2VPN-XC-BRIEF-FIRST-LAYER;
      }  // list ac1
    }  // grouping L2VPN-XC-BRIEF-MATRIX

    grouping L2VPN-XC-BRIEF {
      description "L2VPN XC BRIEF";
      leaf main-total-up {
        type uint32;
        description
          "Total Number of active Cross-Conections with
         valid encaps";
      }

      leaf main-total-down {
        type uint32;
        description
          "Total Number of non-active Cross-Conections with
         valid encaps";
      }

      leaf main-total-unresolved {
        type uint32;
        description
          "Total Number of unresolved Cross-Conections with
         valid encaps";
      }

      leaf undefined-xc {
        type uint32;
        description
          "Undefined xc including PW-PW";
      }

      leaf memory-state {
        type L2vpn-memory-state;
        description "L2VPN memory state";
      }

      list encapsulation-report-matrix {
        max-elements 4;
        description
          "Encapsulation report counters matrix";
        uses L2VPN-XC-BRIEF-MATRIX;
      }  // list encapsulation-report-matrix

      list encapsulation-total {
        max-elements 4;
        description "Total summary";
        uses L2VPN-XC-BRIEF-LINE;
      }  // list encapsulation-total
    }  // grouping L2VPN-XC-BRIEF

    grouping L2VPN-FXC {
      description "L2VPN FXC";
      leaf fxc-id {
        type uint32;
        description "Flexible XConnect ID";
      }

      leaf name {
        type string;
        description
          "Flexible XConnect Service Name";
      }

      leaf state {
        type L2vpn-xc-state;
        description
          "State of the Flexible XConnect Service";
      }

      leaf num-p-ws {
        type uint8;
        description
          "Number of Pseudowires in Pseudowire List";
      }

      list pseudowire {
        max-elements 2;
        description
          "Flexible XConnect Service Pseudowire List";
        uses L2VPN-PW;
      }  // list pseudowire
    }  // grouping L2VPN-FXC

    grouping L2VPN-FXC-AC {
      description "L2VPN FXC AC";
      container attachment-circuit {
        description
          "Flexible XConnect Service Attachment Circuit";
        uses L2VPN-AC;
      }  // container attachment-circuit
    }  // grouping L2VPN-FXC-AC

    grouping L2VPN-PBB-BMAC-SA {
      description "L2VPN PBB BMAC SA";
      leaf provisioned {
        type boolean;
        description "BMAC SA configured";
      }

      leaf chassis-is-provisioned {
        type boolean;
        description
          "Chassis MAC is configured";
      }

      leaf bmac-sa {
        type yang:mac-address;
        description "BMAC SA";
      }

      leaf chassis-mac {
        type yang:mac-address;
        description "Chassis MAC";
      }
    }  // grouping L2VPN-PBB-BMAC-SA

    grouping L2VPN-MSTP-SUBINT {
      description "L2VPN MSTP Subinterfaces";
      leaf interface-name {
        type string;
        description "Interface name";
      }
    }  // grouping L2VPN-MSTP-SUBINT

    grouping L2VPN-MSTP-VLAN {
      description "L2VPN MSTP VLAN";
      leaf vlan-id-xr {
        type uint32;
        description "Vlan id";
      }

      leaf msti-id {
        type uint32;
        description "MSTI id";
      }

      leaf port-count {
        type uint32;
        description "Port Count";
      }

      list sub-interface {
        description "Sub interfaces";
        uses L2VPN-MSTP-SUBINT;
      }  // list sub-interface
    }  // grouping L2VPN-MSTP-VLAN

    grouping L2VPN-MVRP-BP {
      description "L2VPN MVRP BP";
      leaf bridge-port-interface-name {
        type string;
        description
          "Bridge port Interface name";
      }

      leaf bridge-port-xconnect-id {
        type uint32;
        description
          "Bridge port XConnect ID";
      }

      leaf mvrp-sequence-number {
        type uint16;
        description "MVRP Sequence Number";
      }

      list vlan-range {
        description "VLAN IDs";
        uses L2VPN-EFP-RANGE;
      }  // list vlan-range
    }  // grouping L2VPN-MVRP-BP

    grouping L2VPN-MVRP {
      description "L2VPN MVRP";
      container default-bridge-port {
        description
          "Trunk or default Bridge Port";
        uses L2VPN-MVRP-BP;
      }  // container default-bridge-port

      leaf main-port-interface-name {
        type string;
        description
          "Main Port Interface name";
      }

      leaf is-trunk {
        type boolean;
        description "Is main port a trunk";
      }

      leaf is-default-encap {
        type boolean;
        description "Is default encap set";
      }

      leaf number-of-bridge-ports {
        type uint32;
        description "Number of Bridge Ports";
      }
    }  // grouping L2VPN-MVRP

    grouping L2VPN-COLLAB-CNTR {
      description
        "L2VPN collaborator statistics";
      leaf collaborator-name {
        type string;
        description "Collaborator Name";
      }

      leaf up {
        type uint32;
        description "Up";
      }

      leaf down {
        type uint32;
        description "Down";
      }

      leaf is-up {
        type boolean;
        description "Is up";
      }
    }  // grouping L2VPN-COLLAB-CNTR

    grouping L2VPN-COLLAB-STATS {
      description
        "L2VPN collaborator statistics";
      list count {
        max-elements 1;
        description "count";
        uses L2VPN-COLLAB-CNTR;
      }  // list count
    }  // grouping L2VPN-COLLAB-STATS

    grouping L2VPN-GLOBAL-INFO {
      description "L2VPN Global Information";
      container collaborator-statistics {
        description
          "Collaborator Statistics";
        uses L2VPN-COLLAB-STATS;
      }  // container collaborator-statistics
    }  // grouping L2VPN-GLOBAL-INFO

    grouping L2VPN-SOURCE-ADDRESS {
      description "L2VPN SOURCE ADDRESS";
      leaf configuration {
        type L2vpn-src-address-set;
        description "Configuration";
      }

      leaf address {
        when "../configuration = 'set'" {
          description
            "../Configuration = 'Set'";
        }
        type inet:ipv4-address;
        description "Local source address";
      }
    }  // grouping L2VPN-SOURCE-ADDRESS

    grouping L2VPN-L2TPV3-PW-CLASS {
      description "L2VPN L2TPV3 PW CLASS";
      leaf l2tp-class-name {
        type string {
          length "0..32";
        }
        description "L2TPClassName";
      }

      leaf ipv4-source-address {
        type inet:ipv4-address;
        description "IPv4 source address";
      }

      leaf path-mtu-enabled {
        type boolean;
        description "Path MTU enabled";
      }

      leaf path-mtu-max-value {
        type uint16;
        description
          "Path MTU Maximum allowable session MTU";
      }

      leaf dont-fragment-bit {
        type boolean;
        description "Don't Fragment Bit";
      }

      leaf tos-mode {
        type L2vpn-tos-mode;
        description "Type Of Service Mode";
      }

      leaf tos {
        type uint8;
        description "Type Of Service Value";
      }

      leaf ttl {
        type uint8;
        description "Time To Live value";
      }

      leaf cookie-size {
        type uint8;
        description
          "Cookie size: 0, 4, or 8 bytes";
      }
    }  // grouping L2VPN-L2TPV3-PW-CLASS

    grouping L2VPN-ENCAP-PW-CLASS {
      description "L2VPN ENCAP PW CLASS";
      container l2tpv3 {
        when
          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
          description
            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
        }
        description "l2tpv3";
        uses L2VPN-L2TPV3-PW-CLASS;
      }  // container l2tpv3

      leaf encapsulation {
        type L2vpn-encap-method;
        description "Encapsulation";
      }
    }  // grouping L2VPN-ENCAP-PW-CLASS

    grouping L2VPN-PW-CLASS {
      description "L2VPN PW CLASS";
      container encapsulation-info {
        description
          "Encapsulation specific pseudowire information";
        uses L2VPN-ENCAP-PW-CLASS;
      }  // container encapsulation-info

      container preferred-path {
        description "MPLS Preferred Path";
        uses L2VPN-PW-MPLS-PREFPATH;
      }  // container preferred-path

      container local-source-address {
        description "Local source address";
        uses L2VPN-SOURCE-ADDRESS;
      }  // container local-source-address

      leaf pw-class-name {
        type string {
          length "0..33";
        }
        description "Pseudowire class name";
      }

      leaf control-word {
        type L2vpn-pw-class-control-word;
        description "Control word";
      }

      leaf transport-mode {
        type L2vpn-transport-mode;
        description "Transport mode";
      }

      leaf sequencing-type {
        type L2vpn-pw-sequence;
        description "Sequencing Type";
      }

      leaf resync-enabled {
        type boolean;
        description
          "Resync if packets out of sequence";
      }

      leaf resync-threshold {
        type uint32;
        description
          "Number of Packets Out of Seqence to trigger
         resync";
      }

      leaf protocol {
        type L2vpn-signalling-proto;
        description "Protocol";
      }

      leaf disable-never {
        type boolean;
        description
          "TRUE if backup is not automatically disabled";
      }

      leaf disable-delay {
        type uint8;
        description "Disable Deley";
      }

      leaf backup-mac-withdraw {
        type boolean;
        description
          "TRUE if MAC withdraw message is sent";
      }

      leaf tag-rewrite {
        type uint16;
        description "Static tag rewrite";
      }

      leaf preferred-path-disable-fallback {
        type boolean;
        description
          "PreferredPathDisableFallback";
      }

      leaf load-balance {
        type L2vpn-load-bal;
        description "Load Balance Type";
      }

      leaf pw-flow-label-type-cfg {
        type L2vpn-pw-flow-label;
        description
          "Configured pseudowire flow label type";
      }

      leaf pw-flow-label-code17-disabled {
        type boolean;
        description
          "Disable sending Code 17 TLV";
      }

      leaf is-flow-label-static {
        type boolean;
        description "is flow label static";
      }
    }  // grouping L2VPN-PW-CLASS

    grouping L2VPN-G8032-RING-INSTANCE-DETAIL-INFO {
      description
        "L2VPN ethernet ring instance info detail";
      leaf ring-instance {
        type uint32;
        description "Ring instance number";
      }

      leaf ring-description {
        type string;
        description "Ring description";
      }

      leaf ring-profile {
        type string;
        description "Ring Profile";
      }

      leaf rpl {
        type L2vpn-g8032-rpl;
        description "RPL";
      }

      leaf aps-port0 {
        type string;
        description "Port 0 of aps-channel";
      }

      leaf aps-port1 {
        type string;
        description "Port 1 of aps-channel";
      }

      leaf config-state {
        type boolean;
        description "State of the instance";
      }

      leaf unresolved-reason {
        type L2vpn-g8032-uncfg-reason;
        description
          "Reason of unresolved state state";
      }

      leaf aps-channel-level {
        type uint32;
        description "APS channel level";
      }

      list included-vlan-id {
        description
          "Inclusion list Vlan Ids";
        leaf entry {
          type uint16;
          description
            "Inclusion list Vlan Ids";
        }
      }  // list included-vlan-id
    }  // grouping L2VPN-G8032-RING-INSTANCE-DETAIL-INFO

    grouping L2VPN-G8032-RING-SUMMARY-INFO {
      description
        "L2VPN ethernet ring info summary";
      leaf ring-name {
        type string;
        description "Name of the ring";
      }

      leaf port0 {
        type string;
        description "Port 0";
      }

      leaf port1 {
        type string;
        description "Port 1";
      }
    }  // grouping L2VPN-G8032-RING-SUMMARY-INFO

    grouping L2VPN-G8032-RING-INSTANCE-SUMMARY-INFO {
      description
        "L2VPN ethernet ring instance info summary";
      leaf ring-instance {
        type uint32;
        description "Ring instance number";
      }

      leaf aps-port0 {
        type string;
        description "Port 0 of aps-channel";
      }

      leaf aps-port1 {
        type string;
        description "Port 1 of aps-channel";
      }

      leaf config-state {
        type boolean;
        description "State of the instance";
      }

      list included-vlan-id {
        description
          "Inclusion list Vlan Ids";
        leaf entry {
          type uint16;
          description
            "Inclusion list Vlan Ids";
        }
      }  // list included-vlan-id
    }  // grouping L2VPN-G8032-RING-INSTANCE-SUMMARY-INFO

    grouping L2VPN-G8032-RING-DETAIL-INFO {
      description
        "L2VPN ethernet ring info detail";
      leaf ring-name {
        type string;
        description "Name of the ring";
      }

      leaf port0 {
        type string;
        description "Port 0";
      }

      leaf port1 {
        type string;
        description "Port 1";
      }

      leaf monitor0 {
        type string;
        description "Monitor port 0";
      }

      leaf monitor1 {
        type string;
        description "Monitor port 1";
      }

      leaf is-provider-bridge {
        type boolean;
        description
          "Operating mode Customer/Provider ";
      }

      leaf is-open-ring {
        type boolean;
        description "Flag open ring";
      }

      leaf tcn-propagation {
        type boolean;
        description "Global TCN propagation";
      }

      list excluded-vlan-id {
        description
          "Exclusion Vlan ids list ";
        leaf entry {
          type uint16;
          description
            "Exclusion Vlan ids list ";
        }
      }  // list excluded-vlan-id
    }  // grouping L2VPN-G8032-RING-DETAIL-INFO

    grouping L2VPN-DISCO-SUMMARY {
      description "L2VPN DISCO SUMMARY";
      leaf number-bridge-domainvpns {
        type uint32;
        description
          "Number of BDs registered";
      }

      leaf number-mp2m-pxconnect-vpns {
        type uint32;
        description
          "Number of XCs registered";
      }

      leaf number-local-edges-bridge-domain {
        type uint32;
        description "Number of local Edges";
      }

      leaf number-remote-edges-bridge-domain {
        type uint32;
        description "Number of Remote Edges";
      }

      leaf number-nlri-bridge-domain {
        type uint32;
        description "Number of NLRI";
      }

      leaf number-local-edges-xconnect {
        type uint32;
        description "Number of local Edges";
      }

      leaf number-remote-edges-xconnect {
        type uint32;
        description "Number of Remote Edges";
      }

      leaf number-nlri-xconnect {
        type uint32;
        description "Number of NLRI";
      }

      leaf bgp-stateon-active-rp {
        type boolean;
        description
          "BGP state on the active RP";
      }

      leaf bgp-stateon-standby-rp {
        type boolean;
        description
          "BGP state on standby RP";
      }

      leaf vpls-registered {
        type boolean;
        description
          "Is the VPLS service registered";
      }

      leaf vpws-registered {
        type boolean;
        description
          "Is the VPWS service registered";
      }

      leaf bgp-ipc-transport-mode {
        type L2vpn-ipc-transport-mode;
        description
          "IPC Transport mode with BGP";
      }

      leaf bgp-current-node-id {
        type xr:Node-id;
        description "BGP current node id";
      }
    }  // grouping L2VPN-DISCO-SUMMARY

    grouping L2VPN-BRIDGE-VNI {
      description "L2VPN BRIDGE VNI";
      container security-parameters {
        description "Security Parameters";
        uses L2VPN-BRIDGE-PORT-SEC-PARAM;
      }  // container security-parameters

      container statistics {
        description "Statistics";
        uses L2FIB-STATS-BAG-FORWARDING;
      }  // container statistics

      leaf vni {
        type uint32;
        description "VNI";
      }

      leaf overlay {
        type string;
        description "NVE Overlay";
      }

      leaf source-ip-addr {
        type inet:ipv4-address;
        description "Source IP Address";
      }

      leaf multicast-group-addr {
        type inet:ipv4-address;
        description
          "Multicast Group Address";
      }

      leaf anycast-vtep-ip-addr {
        type inet:ipv4-address;
        description
          "Anycast VTEP IP Address";
      }

      leaf anycast-mcast-group-addr {
        type inet:ipv4-address;
        description
          "Anycast Multicast Group Address";
      }

      leaf udp-port {
        type uint32;
        description "UDP Port";
      }

      leaf vni-encap-type {
        type L2vpn-vni-encaps;
        description "VNI Encapsulation Type";
      }

      leaf vni-port-state {
        type L2vpn-segment-state;
        description "VNI Port State";
      }

      leaf vni-mode {
        type L2vpn-vni-mode;
        description "VNI Mode";
      }

      leaf ingress-replication {
        type boolean;
        description
          "VNI Ingress Replication is enabled";
      }

      leaf xconnect-id {
        type uint32;
        description "Xconnect ID";
      }

      list static-mac {
        description "Static MAC addresses";
        uses L2VPN-BD-MAC;
      }  // list static-mac
    }  // grouping L2VPN-BRIDGE-VNI

    grouping L2VPN-BD-EVPN-PORT {
      description "L2VPN EVPN port";
      container security-parameters {
        description "Security Parameters";
        uses L2VPN-BRIDGE-PORT-SEC-PARAM;
      }  // container security-parameters

      container statistics {
        description "Statistics";
        uses L2FIB-STATS-BAG-FORWARDING;
      }  // container statistics

      leaf xconnect-id {
        type uint32;
        description "Xconnect ID";
      }

      leaf evpn-port-state {
        type L2vpn-virtualport-state;
        description "EVPN Port State";
      }
    }  // grouping L2VPN-BD-EVPN-PORT

    grouping L2VPN-BRIDGE-EVPN-PARAMS {
      description "L2VPN BRIDGE EVPN PARAMS";
      container evpn-port {
        description "EVPN Port";
        uses L2VPN-BD-EVPN-PORT;
      }  // container evpn-port

      leaf evi {
        type uint32;
        description "E-VPN id";
      }
    }  // grouping L2VPN-BRIDGE-EVPN-PARAMS

    grouping L2VPN-BD-PBB-CORE-PORT {
      description "L2VPN PBB core port";
      container security-parameters {
        description "Security Parameters";
        uses L2VPN-BRIDGE-PORT-SEC-PARAM;
      }  // container security-parameters

      leaf xconnect-id {
        type uint32;
        description "Xconnect ID";
      }

      leaf vlan-id {
        type uint32;
        description "Vlan ID";
      }

      leaf core-port-state {
        type L2vpn-virtualport-state;
        description "PBB Core Port State";
      }
    }  // grouping L2VPN-BD-PBB-CORE-PORT

    grouping L2VPN-BRIDGE-PBB-CORE {
      description "L2VPN BRIDGE PBB CORE";
      container core-port {
        description "PBB Core Port";
        uses L2VPN-BD-PBB-CORE-PORT;
      }  // container core-port

      leaf num-ass-edge {
        type uint32;
        description
          "Number of Associated PBB Edges";
      }
    }  // grouping L2VPN-BRIDGE-PBB-CORE

    grouping L2VPN-BD-PBB-EDGE-PORT {
      description "L2VPN PBB edge port";
      container security-parameters {
        description "Security Parameters";
        uses L2VPN-BRIDGE-PORT-SEC-PARAM;
      }  // container security-parameters

      container statistics {
        description "Statistics";
        uses L2FIB-STATS-BAG-FORWARDING;
      }  // container statistics

      leaf xconnect-id {
        type uint32;
        description "Xconnect ID";
      }

      leaf unknown-unicast-mac-set {
        type boolean;
        description
          "Unknown Unicast MAC Configured";
      }

      leaf unknown-unicast-mac {
        type yang:mac-address;
        description "Unknown Unicast MAC";
      }

      leaf edge-port-state {
        type L2vpn-virtualport-state;
        description "PBB Edge Port State";
      }

      list bmac-mapping {
        description "CMAC to BMAC Mapping";
        uses L2VPN-BD-MAC;
      }  // list bmac-mapping
    }  // grouping L2VPN-BD-PBB-EDGE-PORT

    grouping L2VPN-BRIDGE-PBB-EDGE {
      description "L2VPN BRIDGE PBB EDGE";
      container edge-port {
        description "PBB Edge Port";
        uses L2VPN-BD-PBB-EDGE-PORT;
      }  // container edge-port

      leaf i-sid {
        type uint32;
        description "SID";
      }

      leaf core-bridge-name {
        type string;
        description
          "Core Bridge Domain Name";
      }

      leaf core-bridge-state {
        type L2vpn-bridge-state;
        description "Core Bridge State";
      }

      leaf mirp-lite-status {
        type L2vpn-mirp-lite-status;
        description "MIRP-lite Status";
      }

      leaf mirp-lite-protocol {
        type L2vpn-mirp-lite-protocol-info;
        description
          "MIRP-lite protocol info";
      }
    }  // grouping L2VPN-BRIDGE-PBB-EDGE

    grouping L2VPN-BRIDGE-PBB-PARAMS {
      description "L2VPN BRIDGE PBB PARAMS";
      container pbb-edge {
        when
          "../type = 'l2vpn-bridge-type-pbb-edge'" {
          description
            "../Type = 'L2VPN_BRIDGE_TYPE_PBB_EDGE'";
        }
        description "PBB Edge";
        uses L2VPN-BRIDGE-PBB-EDGE;
      }  // container pbb-edge

      container pbb-core {
        when
          "../type = 'l2vpn-bridge-type-pbb-core'" {
          description
            "../Type = 'L2VPN_BRIDGE_TYPE_PBB_CORE'";
        }
        description "PBB Core";
        uses L2VPN-BRIDGE-PBB-CORE;
      }  // container pbb-core

      leaf type {
        type L2vpn-bridge;
        description "Type";
      }
    }  // grouping L2VPN-BRIDGE-PBB-PARAMS

    grouping L2VPN-VFI-P2MP {
      description "L2VPN VFI P2MP";
      leaf transport {
        type L2vpn-vfi-p2mp-transport;
        description "P2MP transport";
      }

      leaf signaling {
        type L2vpn-vfi-p2mp-signaling;
        description "P2MP signaling";
      }

      leaf ptree-id {
        type uint32;
        description "PTree ID";
      }

      leaf attribute-set-name {
        type string;
        description "TE Attribute Set Name";
      }

      leaf transport-status {
        type P2mp-transport-state;
        description "Transport Status";
      }

      leaf local-label {
        type uint32;
        description
          "P2MP Tunnel Local Label";
      }

      leaf tunnel-interface {
        type xr:Interface-name;
        description
          "P2MP Tunnel Interface Name";
      }
    }  // grouping L2VPN-VFI-P2MP

    grouping L2VPN-BD-DISCO {
      description "L2VPN BD DISCO";
      container rd-value {
        description "Route Distinguisher";
        uses L2VPN-RD;
      }  // container rd-value

      container vpls-id {
        description "VPLS ID";
        uses L2VPN-VPLS-ID;
      }  // container vpls-id

      leaf vpn-id {
        type uint32;
        description "Vpn ID";
      }

      leaf ad-signalling-method {
        type uint32;
        description "Signaling protocol";
      }

      leaf ad-method {
        type uint32;
        description "Autodiscovery method";
      }

      leaf ve-id {
        type uint32;
        description "VPLS Edge ID";
      }

      leaf provisioned-ve-id {
        type uint32;
        description
          "Provisioned VPLS edge ID";
      }

      leaf ve-range {
        type uint16;
        description "VE range";
      }

      leaf as-number {
        type uint32;
        description
          "Autonomous System Number";
      }

      leaf l2vpn-router-id {
        type inet:ipv4-address;
        description "L2PVN Router ID";
      }

      leaf vpn-added {
        type boolean;
        description "Is VPN id configured";
      }

      leaf service-connected {
        type boolean;
        description
          "Is the BGP service connected?";
      }

      leaf vpls-id-conflict {
        type boolean;
        description "VPLS-ID Conflict";
      }

      leaf export-route-policy {
        type string;
        description "Export Route Policy";
      }

      list import-rt {
        description
          "List of import route targets";
        uses L2VPN-RT;
      }  // list import-rt

      list export-rt {
        description
          "List of export route targets";
        uses L2VPN-RT;
      }  // list export-rt
    }  // grouping L2VPN-BD-DISCO

    grouping L2VPN-VFI {
      description
        "L2VPN Virtual Forwarding Instance";
      container discovery-information {
        description
          "Auto Discovery information";
        uses L2VPN-BD-DISCO;
      }  // container discovery-information

      leaf vfi-name {
        type string;
        description
          "Virtual forwarding instance name";
      }

      leaf shutdown {
        type boolean;
        description "Shutdown";
      }

      leaf access {
        type boolean;
        description "VFI is an Access VFI";
      }

      leaf vfi-state {
        type L2vpn-vfi-state;
        description "VFI state";
      }

      leaf number-pseudowires {
        type uint32;
        description "Number of Pseudowires";
      }

      list p2mp-information {
        description
          "Multicast P2MP information";
        uses L2VPN-VFI-P2MP;
      }  // list p2mp-information
    }  // grouping L2VPN-VFI

    grouping L2VPN-BRIDGE {
      description "L2VPN BRIDGE";
      container security-parameters {
        description "Security parameters";
        uses L2VPN-BRIDGE-SEC-PARAM;
      }  // container security-parameters

      container pbb-parameters {
        description "PBB parameters";
        uses L2VPN-BRIDGE-PBB-PARAMS;
      }  // container pbb-parameters

      container evpn-parameters {
        description "EVPN parameters";
        uses L2VPN-BRIDGE-EVPN-PARAMS;
      }  // container evpn-parameters

      container vni-parameters {
        description "VNI parameters";
        uses L2VPN-BRIDGE-VNI;
      }  // container vni-parameters

      container rd {
        description "Route Distinguisher";
        uses L2VPN-RD;
      }  // container rd

      leaf group-name {
        type string;
        description "Group name";
      }

      leaf bridge-name {
        type string;
        description "Bridge-domain name";
      }

      leaf bridge-domain-id {
        type uint32;
        description "Identification number";
      }

      leaf bridge-description {
        type string;
        description
          "Human-readable bridge-domain description";
      }

      leaf bridge-state {
        type L2vpn-bridge-state;
        description "Bridge-domain state";
      }

      leaf bridge-coupled-state {
        type L2vpn-bridge-coupled-state;
        description
          "Bridge-domain coupled state";
      }

      leaf bridge-shg-id {
        type uint32;
        description "Bridge-domain shgid";
      }

      leaf bridge-msti {
        type uint32;
        description "Bridge-domain msti";
      }

      leaf acpwup {
        type uint32;
        description
          "Number of bridge ports (AC,PW) which are up";
      }

      leaf bridge-internal-msti {
        type uint32;
        description
          "Bridge-domain internal msti";
      }

      leaf configured {
        type boolean;
        description
          "Bridge-domain is configured";
      }

      leaf number-vf-is {
        type uint32;
        description
          "Number of virtual forwarding interfaces";
      }

      leaf number-access-vf-is {
        type uint32;
        description "Number of Access VFIs";
      }

      leaf number-a-cs {
        type uint32;
        description
          "Number of attachment circuits";
      }

      leaf number-a-cs-up {
        type uint32;
        description
          "Number of attachment circuits up";
      }

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

      leaf number-p-ws-up {
        type uint32;
        description
          "Number of pseudowires up";
      }

      leaf standby-pseudowires {
        type uint32;
        description
          "Number of pseudowires standby";
      }

      leaf number-pb-bs {
        type uint8;
        description "Number of pbbs";
      }

      leaf number-pb-bs-up {
        type uint8;
        description "Number of pbbs up";
      }

      leaf num-vn-is {
        type uint32;
        description "Number of VNIs";
      }

      leaf num-vn-is-up {
        type uint32;
        description "Number of VNIs up";
      }

      leaf partially-programmed-pseudowires {
        type uint32;
        description
          "Number of pseudowires partially programmed";
      }

      leaf partially-programmed-a-cs {
        type uint32;
        description
          "Number of attachment circuits partially
         programmed";
      }

      leaf bridge-mtu {
        type uint32;
        description
          "Maximum transmission unit";
      }

      leaf shutdown {
        type boolean;
        description
          "Administratively disabled";
      }

      leaf mac-limit-down {
        type boolean;
        description
          "Oper down because MAC limit reached";
      }

      leaf flodd-group-id-down {
        type boolean;
        description
          "Oper down because no FGID";
      }

      leaf mac-withdraw {
        type boolean;
        description "MAC withdraw enabled";
      }

      leaf mac-withdraw-access {
        type boolean;
        description
          "MAC Access PW withdraw enabled";
      }

      leaf mac-withdraw-relay {
        type boolean;
        description
          "MAC Access PW withdraw relaying from access to
         access enabled";
      }

      leaf mac-withdraw-option {
        type L2vpn-bag-mac-withdraw-option;
        description
          "Event on which MAC withdraw is sent";
      }

      leaf p2mp-enabled {
        type boolean;
        description
          "P2MP Enabled on this Bridge Domain";
      }

      leaf bridge-type {
        type L2vpn-bridge;
        description "Bridge-domain type";
      }

      leaf vine-fsm-state {
        type string;
        description
          "VNI, IRB, Native-Evpn state";
      }

      leaf time-created {
        type string {
          length "0..50";
        }
        description
          "Time when the bridge domain was created";
      }

      leaf time-elapsed-creation {
        type string {
          length "0..50";
        }
        description
          "Time elapsed since creation";
      }

      leaf last-time-status-changed {
        type string {
          length "0..50";
        }
        description
          "Last time the bridge domain status changed";
      }

      leaf time-elapsed-status-changed {
        type string {
          length "0..50";
        }
        description
          "Time elapsed since status changed";
      }

      leaf load-balance {
        type L2vpn-load-bal;
        description "Load Balance Type";
      }

      leaf is-bridge-partially-programmed {
        type boolean;
        description
          "Bridge is partially programmed";
      }

      leaf evi {
        type uint32;
        description "E-VPN id";
      }

      leaf is-rd-configured {
        type boolean;
        description "Config or Auto";
      }

      leaf imposition-pkt-count {
        type uint64;
        description
          "EVPN Imposition Packet Count";
      }

      leaf imposition-byte-count {
        type uint64;
        description
          "EVPN Imposition Byte Count";
      }

      leaf disposition-pkt-count {
        type uint64;
        description
          "EVPN Disposition Packet Count";
      }

      leaf disposition-bytecount {
        type uint64;
        description
          "EVPN Disposition Byte Count";
      }

      leaf as {
        type uint32;
        description "BGP AS number";
      }

      leaf nv-satellite-offload-ipv4-multicast-disabled {
        type boolean;
        description
          "nV Satellite Offload IPv4 Multicast Disabled";
      }

      list mac-filter {
        description
          "MAC addresses for filtering";
        uses L2VPN-BD-MAC;
      }  // list mac-filter

      list bridge-vfi {
        description
          "Virtual Forwarding Interfaces";
        uses L2VPN-VFI;
      }  // list bridge-vfi

      list bridge-access-vfi {
        description
          "Access Virtual Forwarding Interfaces";
        uses L2VPN-VFI;
      }  // list bridge-access-vfi
    }  // grouping L2VPN-BRIDGE

    grouping L2VPN-BD-AC {
      description
        "L2VPN Bridge Attachment Circuit";
      container attachment-circuit {
        description "Attachment Circuit";
        uses L2VPN-AC;
      }  // container attachment-circuit

      container security-parameters {
        description "Security Parameters";
        uses L2VPN-BRIDGE-PORT-SEC-PARAM;
      }  // container security-parameters

      leaf bvi-mac-index {
        type uint16;
        description "MyMac Index";
      }

      list static-mac {
        description "Static MAC addresses";
        uses L2VPN-BD-MAC;
      }  // list static-mac

      list bvimac {
        description "BVI MAC addresses";
        uses L2VPN-BD-MAC;
      }  // list bvimac
    }  // grouping L2VPN-BD-AC

    grouping L2VPN-BAG-STORM-CONTROL-TYPE {
      description
        "Storm Control Configuration";
      leaf bd-policer {
        type boolean;
        description "Bridge Domain Policer";
      }

      leaf unicast {
        type boolean;
        description
          "Unknown-unicast Storm Control";
      }

      leaf multicast {
        type boolean;
        description
          "Multicast Storm Control";
      }

      leaf broadcast {
        type boolean;
        description
          "Broadcast Storm Control";
      }
    }  // grouping L2VPN-BAG-STORM-CONTROL-TYPE

    grouping L2VPN-BRIDGE-SEC-PARAM {
      description "L2VPN BRIDGE SEC PARAM";
      container storm-control {
        description
          "Storm Control Configuration";
        uses L2VPN-BAG-STORM-CONTROL-TYPE;
      }  // container storm-control

      leaf mac-limit {
        type uint32;
        description "MAC address limit";
      }

      leaf mac-limit-action {
        type L2vpn-bag-mac-limit-action;
        description "MAC limit action";
      }

      leaf mac-limit-notification {
        type L2vpn-bag-mac-limit-notify;
        description "MAC limit notification";
      }

      leaf mac-aging-time {
        type uint32;
        units "second";
        description
          "MAC aging time in seconds";
      }

      leaf mac-aging-mode {
        type L2vpn-bag-mac-aging-mode;
        description "MAC Aging Mode";
      }

      leaf mac-flooding {
        type boolean;
        description "MAC flooding enabled";
      }

      leaf mac-learning {
        type boolean;
        description "MAC learning enabled";
      }

      leaf learn-disabled-mac-limit-action {
        type boolean;
        description
          "Learning disabled due to MAC limit action";
      }

      leaf flood-uu-disabled-mac-limit-action {
        type boolean;
        description
          "Flooding of unknown-unicast disabled due to MAC
         limit action";
      }

      leaf mac-limit-reached {
        type boolean;
        description "MAC limit reached";
      }

      leaf mac-limit-threshold {
        type uint32;
        units "percentage";
        description
          "MAC Limit Threshold Percentage";
      }

      leaf flood-unknown-unicast-enabled {
        type boolean;
        description
          "Flooding unknown unicast enabled";
      }

      leaf mac-port-down-flush-enabled {
        type boolean;
        description
          "MAC Flush when port goes down";
      }

      leaf split-horizon-group-id {
        type uint32;
        description "Split Horizon Group ID";
      }

      leaf split-horizon-group-inherited {
        type boolean;
        description
          "Is Split Horizon Group Inherited";
      }

      leaf etree-leaf {
        type boolean;
        description "E-Tree Leaf Indication";
      }

      leaf etree-leaf-inherited {
        type boolean;
        description
          "Is E-Tree Leaf Indication Inherited";
      }

      leaf is-ip-source-guard-enabled {
        type boolean;
        description
          "Is IP Source Guard Enabled";
      }

      leaf is-ipsg-logging-enabled {
        type boolean;
        description
          "Is IP Source Guard Logging Enabled";
      }

      leaf is-dai-enabled {
        type boolean;
        description
          "Is Dynamic ARP Inspection Enabled";
      }

      leaf is-dai-logging-enabled {
        type boolean;
        description "Is DAI Logging Enabled";
      }

      leaf is-dai-addr-validate-source-mac-enabled {
        type boolean;
        description
          "Is DAI Source MAC Address Validation Enabled";
      }

      leaf is-dai-addr-validate-destination-mac-enabled {
        type boolean;
        description
          "Is DAI Dstination MAC Address Validation Enabled";
      }

      leaf is-dai-addr-validate-ipv4-enabled {
        type boolean;
        description
          "Is DAI IPv4 Addr Validation Enabled";
      }

      leaf is-mac-secure-enabled {
        type boolean;
        description "Is MAC Secure Enabled";
      }

      leaf mac-secure-action {
        type L2vpn-bag-mac-secure-action;
        description "MAC Secure Action";
      }

      leaf is-mac-secure-logging-enabled {
        type boolean;
        description
          "Is MAC Secure Logging Enabled";
      }

      leaf is-mac-secure-accept-shutdown-enabled {
        type boolean;
        description
          "Is MAC Secure Accept Shutdown Enabled (BP only)";
      }

      leaf is-mac-secure-threshold-enabled {
        type boolean;
        description
          "Is MAC Secure Threshold Enabled";
      }

      leaf mac-secure-shutdown-recovery-time {
        type uint16;
        description
          "MAC Secure Shutdown Action Recovery Timer";
      }

      leaf mac-secure-shutdown-recovery-time-remaining {
        type uint16;
        description
          "Remaining time for MAC Secure shutdown Action
         Recovery Timer";
      }

      leaf dai-address-validation-mask {
        type uint8;
        description
          "DAI Address Validation mask";
      }

      leaf dhcpv4-snoop {
        type boolean;
        description "DHCPv4 Snoop Status";
      }

      leaf dhcpv4-profile-name {
        type string;
        description "DHCPv4 Profile Name";
      }

      leaf igm-pv4-disabled {
        type boolean;
        description "IGMPv4 Disabled";
      }

      leaf igm-pv4-profile-name {
        type string;
        description "IGMPv4 Profile Name";
      }

      leaf mld-profile-name {
        type string;
        description "MLD Profile Name";
      }

      leaf mmrp-flood-optimization {
        type boolean;
        description
          "MMRP Flood Optimization Status";
      }

      leaf unicast-storm-control-rate-unit {
        type L2vpn-bag-storm-control-rate-unit;
        description
          "Unicast Storm Control Rate Unit";
      }

      leaf unicast-storm-control-pps {
        type uint64;
        description
          "Unicast Storm Control PPS";
      }

      leaf unicast-storm-control-kb-ps {
        type uint64;
        units "kbit/s";
        description
          "Unicast Storm Control KbPS";
      }

      leaf multicast-storm-control-rate-unit {
        type L2vpn-bag-storm-control-rate-unit;
        description
          "Multicast Storm Control Rate Unit";
      }

      leaf multicast-storm-control-pps {
        type uint64;
        description
          "Multicast Storm Control PPS";
      }

      leaf multicast-storm-control-kb-ps {
        type uint64;
        units "kbit/s";
        description
          "Multicast Storm Control KbPS";
      }

      leaf broadcast-storm-control-rate-unit {
        type L2vpn-bag-storm-control-rate-unit;
        description
          "Broadcast Storm Control Rate Unit";
      }

      leaf broadcast-storm-control-pps {
        type uint64;
        description
          "Broadcast Storm Control PPS";
      }

      leaf broadcast-storm-control-kb-ps {
        type uint64;
        units "kbit/s";
        description
          "Broadcast Storm Control KbPS";
      }

      leaf l2mc-src-traffic-enabled {
        type L2vpn-bag-l2mc-src-traffic;
        description
          "L2MC Src Traffic Enabled";
      }
    }  // grouping L2VPN-BRIDGE-SEC-PARAM

    grouping L2VPN-BRIDGE-PORT-SEC-PARAM {
      description
        "L2VPN BRIDGE PORT SEC PARAM";
      container base {
        description
          "Basic Security Parameters";
        uses L2VPN-BRIDGE-SEC-PARAM;
      }  // container base

      container storm-control {
        description
          "Storm Control Configuration";
        uses L2VPN-BAG-STORM-CONTROL-TYPE;
      }  // container storm-control

      leaf unicast-storm-control-rate-unit {
        type L2vpn-bag-storm-control-rate-unit;
        description
          "Unicast Storm Control Rate Unit";
      }

      leaf unicast-storm-control-pps {
        type uint64;
        description
          "Unicast Storm Control PPS";
      }

      leaf unicast-storm-control-kb-ps {
        type uint64;
        units "kbit/s";
        description
          "Unicast Storm Control KbPS";
      }

      leaf multicast-storm-control-rate-unit {
        type L2vpn-bag-storm-control-rate-unit;
        description
          "Multicast Storm Control Rate Unit";
      }

      leaf multicast-storm-control-pps {
        type uint64;
        description
          "Multicast Storm Control PPS";
      }

      leaf multicast-storm-control-kb-ps {
        type uint64;
        units "kbit/s";
        description
          "Multicast Storm Control KbPS";
      }

      leaf broadcast-storm-control-rate-unit {
        type L2vpn-bag-storm-control-rate-unit;
        description
          "Broadcast Storm Control Rate Unit";
      }

      leaf broadcast-storm-control-pps {
        type uint64;
        description
          "Broadcast Storm Control PPS";
      }

      leaf broadcast-storm-control-kb-ps {
        type uint64;
        units "kbit/s";
        description
          "Broadcast Storm Control KbPS";
      }

      leaf dhcpv4-trust {
        type boolean;
        description "DHCPv4 Trust Status";
      }
    }  // grouping L2VPN-BRIDGE-PORT-SEC-PARAM

    grouping L2VPN-BD-MAC {
      description "L2VPN Static MAC Address";
      leaf mac {
        type yang:mac-address;
        description "MAC address";
      }

      leaf pbb-bmac {
        type yang:mac-address;
        description "Backbone MAC address";
      }

      leaf nh-addr {
        type inet:ipv4-address;
        description "Next Hop IP";
      }
    }  // grouping L2VPN-BD-MAC

    grouping L2VPN-BD-PW {
      description "L2VPN Bridge Pseudowire";
      container pseudowire {
        description "Pseudowire";
        uses L2VPN-PW;
      }  // container pseudowire

      container security-parameters {
        description "Security Parameters";
        uses L2VPN-BRIDGE-PORT-SEC-PARAM;
      }  // container security-parameters

      leaf is-access {
        type boolean;
        description "Is Access PW";
      }

      list static-mac {
        description "Static MAC addresses";
        uses L2VPN-BD-MAC;
      }  // list static-mac
    }  // grouping L2VPN-BD-PW

    grouping L2VPN-RESOURCE-STATE {
      description "L2VPN Resource State";
      leaf resource-out-of-memory-state {
        type uint32;
        description
          "L2VPN Out of memory state";
      }
    }  // grouping L2VPN-RESOURCE-STATE

    grouping L2VPN-PWHE-RANGE {
      description "L2VPN PWHE RANGE";
      leaf lower {
        type uint16;
        description "lower range";
      }

      leaf upper {
        type uint16;
        description "upper range";
      }
    }  // grouping L2VPN-PWHE-RANGE

    grouping L2VPN-GENERIC-IF-LIST {
      description "L2VPN GENERIC IF LIST";
      leaf interface-list-name-xr {
        type string {
          length "0..33";
        }
        description "Interface-list name";
      }

      leaf interface-list-id {
        type uint32;
        description "Interface internal ID";
      }

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

      leaf items {
        type uint32;
        description "Number of items";
      }

      list interface {
        description "Interfaces";
        uses IFLIST-IF;
      }  // list interface
    }  // grouping L2VPN-GENERIC-IF-LIST

    grouping L2VPN-GENERIC-IF-LIST-DETAIL {
      description
        "L2VPN GENERIC IF LIST DETAIL";
      container summary {
        description "Summary information";
        uses L2VPN-GENERIC-IF-LIST;
      }  // container summary

      leaf items {
        type uint32;
        description "Number of items";
      }

      leaf is-provisioned {
        type boolean;
        description "Is Provisioned";
      }

      leaf psedowire-ether-items {
        type uint32;
        description "Number PW Ether Items";
      }

      leaf pseudowire-iw-items {
        type uint32;
        description "Number PW IW Items";
      }

      list interface {
        max-elements 32;
        description "Interfaces";
        uses IFLIST-IF;
      }  // list interface

      list pseudowire-ether-range {
        description "PW-Ether ranges";
        uses L2VPN-PWHE-RANGE;
      }  // list pseudowire-ether-range

      list pseudowire-iw-range {
        description "PW-IW ranges";
        uses L2VPN-PWHE-RANGE;
      }  // list pseudowire-iw-range
    }  // grouping L2VPN-GENERIC-IF-LIST-DETAIL

    grouping L2VPN-MSTI-BD-ENTRY {
      description "L2VPN MSTi BD Entry";
      leaf bdid {
        type uint32;
        description "BD ID";
      }

      leaf bdif-count {
        type uint32;
        description "BD Intf Count";
      }
    }  // grouping L2VPN-MSTI-BD-ENTRY

    grouping L2VPN-MSTI-ENTRY {
      description "L2VPN MSTI Entry";
      leaf cfg-ms-ti {
        type uint32;
        description " Configured MSTi";
      }

      leaf rcv-count {
        type uint32;
        description "Receive count ";
      }

      leaf ack-count {
        type uint32;
        description "Ack count ";
      }

      leaf nack-count {
        type uint32;
        description "Nack count ";
      }

      leaf flush-count {
        type uint32;
        description "Flush count ";
      }

      leaf interface-count {
        type uint32;
        description "Interface count";
      }

      leaf bd-count {
        type uint32;
        description "BD count";
      }

      leaf msti-flags {
        type uint32;
        description "Msti Flags";
      }

      leaf msti-state {
        type L2vpn-msti-state;
        description "Msti State";
      }

      list bd-entry {
        description "BD entries";
        uses L2VPN-MSTI-BD-ENTRY;
      }  // list bd-entry
    }  // grouping L2VPN-MSTI-ENTRY

    grouping L2VPN-MSTP-PORT {
      description "L2VPN MSTP PORT";
      leaf mstp-interface-handle {
        type xr:Interface-name;
        description "Interface handle";
      }

      leaf interface-name {
        type string;
        description "Interface name";
      }

      leaf protected {
        type boolean;
        description "Protected";
      }

      leaf reference-count {
        type uint32;
        description "Reference Count";
      }

      list msti-entry {
        description "MSTI";
        uses L2VPN-MSTI-ENTRY;
      }  // list msti-entry
    }  // grouping L2VPN-MSTP-PORT

    grouping L2VPN-XC-SUMMARY {
      description "L2VPN XC SUMMARY";
      leaf number-groups {
        type uint32;
        description "Number of groups";
      }

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

      leaf number-xconnects-up {
        type uint32;
        description
          "Numxber of xconnects whose state is up";
      }

      leaf number-xconnects-down {
        type uint32;
        description
          "Number of xconnects whose state is down";
      }

      leaf number-xconnects-unresolved {
        type uint32;
        description
          "Number of xconnects whose state is unresolved";
      }

      leaf number-xconnects-administratively-down {
        type uint32;
        description
          "Number of xconnects with segments in admin down
         state";
      }

      leaf number-xconnects-type-attachment-circuit-to-pseudo-wire {
        type uint32;
        description
          "Number of xconnects of type attachment circuit
         to pseudowire";
      }

      leaf number-xconnects-type-monitor-session-to-pseudo-wire {
        type uint32;
        description
          "Number of xconnects of type monitor session to
         pseudowire";
      }

      leaf number-xconnects-locally-switched {
        type uint32;
        description
          "Number of locally switched xconnects";
      }

      leaf number-xconnects-with-backup-pw {
        type uint32;
        description
          "Number of XCs configured with backup PW";
      }

      leaf number-xconnects-currently-using-backup {
        type uint32;
        description
          "Number of XCs currently using backup PW (UP
         state)";
      }

      leaf down-backup-xconnects {
        type uint32;
        description
          "Number of XCs with backup PW in down state";
      }

      leaf admin-down-backup-xconnects {
        type uint32;
        description
          "Number of XCs with backup PW in admin down state";
      }

      leaf unresolved-backup-xconnects {
        type uint32;
        description
          "Number of XCs with backup PW in unresolved state";
      }

      leaf standby-backup-xconnects {
        type uint32;
        description
          "Number of XCs with backup PW in standby state";
      }

      leaf standby-ready-backup-xconnects {
        type uint32;
        description
          "Number of XCs with backup PW in standby ready
         state";
      }

      leaf out-of-memory-state {
        type uint32;
        description
          "L2VPN Out of memory state";
      }

      leaf number-xconnects-type-pseudo-wire-to-pseudo-wire {
        type uint32;
        description
          "Number of xconnects of type PseudoWire To
         PseudoWire";
      }

      leaf number-mp2mp-xconnects {
        type uint32;
        description
          "Number of mp2mp xconnects";
      }

      leaf number-mp2mp-xconnects-up {
        type uint32;
        description
          "Number of Mp2mp XCs that have been admined up";
      }

      leaf number-mp2mp-xconnects-down {
        type uint32;
        description
          "Number of Mp2mp XCs that have ben admined down";
      }

      leaf number-mp2mp-xconnects-advertised {
        type uint32;
        description
          "Number of Mp2mp XCs that have been advertized";
      }

      leaf number-mp2mp-xconnectss-not-advertised {
        type uint32;
        description
          "Number of Mp2mp XCs that have not been
         advertized";
      }

      leaf number-ce2-ceconnections {
        type uint32;
        description
          "Number of Ce2Ce connections";
      }

      leaf number-ce2ce-advertized {
        type uint32;
        description
          "Number of CE2CE connections that have been
         advertized";
      }

      leaf number-ce2ce-not-advertized {
        type uint32;
        description
          "Number of CE2CE connections that have not been
         advertized";
      }

      leaf partially-programmed-xconnects {
        type uint32;
        description
          "Number of cross-connects partially programmed";
      }

      leaf number-xconnects-with-backup-interface {
        type uint32;
        description
          "Number of XCs configured with backup interface";
      }

      leaf number-xconnects-currently-using-backup-interface {
        type uint32;
        description
          "Number of XCs currently using backup interface
         (UP state)";
      }

      leaf down-backup-interface-xconnects {
        type uint32;
        description
          "Number of XCs with backup interface in down
         state";
      }

      leaf admin-down-backup-interface-xconnects {
        type uint32;
        description
          "Number of XCs with backup interface in admin
         down state";
      }

      leaf unresolved-backup-interface-xconnects {
        type uint32;
        description
          "Number of XCs with backup interface in
         unresolved state";
      }

      leaf standby-backup-interface-xconnects {
        type uint32;
        description
          "Number of XCs with backup interface in standby
         state";
      }
    }  // grouping L2VPN-XC-SUMMARY

    grouping L2VPN-INDEX-INFO {
      description "L2VPN ID Info";
      leaf pool-id-xr {
        type uint32;
        description "Pool Id";
      }

      leaf application-type {
        type L2vpn-id-mgr-app-bag;
        description "Application Type";
      }

      leaf allocated-ids {
        type uint32;
        description
          "Number of IDs allocated";
      }

      leaf zombied-ids {
        type uint32;
        description
          "Number of IDs allocated";
      }

      leaf pool-size {
        type uint32;
        description "Pool size";
      }

      leaf max-num-id-mgr {
        type uint32;
        description
          "Maximum number of pool extensions";
      }

      leaf num-id-mgr-in-use {
        type uint32;
        description
          "ID mgr instances in use";
      }
    }  // grouping L2VPN-INDEX-INFO

    grouping L2VPN-SRTE-POLICY {
      description "L2VPN SRTE Policy object";
      leaf color-xr {
        type uint32;
        description "SRTE policy color";
      }

      leaf endpoint-xr {
        type L2vpn-bag-in6-addr;
        description
          "SRTE policy endpoint address";
      }

      leaf policy-state-is-up {
        type boolean;
        description "Policy is up";
      }

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

      leaf policy-bsid {
        type uint32;
        description "BSID for policy";
      }

      leaf service-count {
        type uint32;
        description
          "Count of number of services registered for
         policy";
      }
    }  // grouping L2VPN-SRTE-POLICY

    grouping L2VPN-RT-ES-IMPORT {
      description "L2VPN RT ES IMPORT";
      leaf high-bytes {
        type uint32;
        description
          "Top 4 bytes of ES Import";
      }

      leaf low-bytes {
        type uint16;
        description
          "Low 2 bytes of ES Import";
      }
    }  // grouping L2VPN-RT-ES-IMPORT

    grouping L2VPN-RT-V4ADDR {
      description "L2VPN RT V4ADDR";
      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPv4 Address";
      }

      leaf two-byte-index {
        type uint16;
        description "2 Byte Index";
      }
    }  // grouping L2VPN-RT-V4ADDR

    grouping L2VPN-RT-4BYTE-AS {
      description "L2VPN RT 4BYTE AS";
      leaf four-byte-as {
        type uint32;
        description "4 Byte AS Number";
      }

      leaf two-byte-index {
        type uint16;
        description "2 Byte Index";
      }
    }  // grouping L2VPN-RT-4BYTE-AS

    grouping L2VPN-RT-2BYTE-AS {
      description "L2VPN RT 2BYTE AS";
      leaf two-byte-as {
        type uint16;
        description "2 Byte AS Number";
      }

      leaf four-byte-index {
        type uint32;
        description "4 Byte Index";
      }
    }  // grouping L2VPN-RT-2BYTE-AS

    grouping L2VPN-RT {
      description "L2VPN RT";
      container two-byte-as {
        when "../rt = 'l2vpn-ad-rt-as'" {
          description
            "../RT = 'L2VPN_AD_RT_AS'";
        }
        description "two byte as";
        uses L2VPN-RT-2BYTE-AS;
      }  // container two-byte-as

      container four-byte-as {
        when
          "../rt = 'l2vpn-ad-rt-4byte-as'" {
          description
            "../RT = 'L2VPN_AD_RT_4BYTE_AS'";
        }
        description "four byte as";
        uses L2VPN-RT-4BYTE-AS;
      }  // container four-byte-as

      container v4-addr {
        when "../rt = 'l2vpn-ad-rt-v4-addr'" {
          description
            "../RT = 'L2VPN_AD_RT_V4ADDR'";
        }
        description "v4 addr";
        uses L2VPN-RT-V4ADDR;
      }  // container v4-addr

      container es-import {
        when "../rt = 'es-import'" {
          description "../RT = 'ES_Import'";
        }
        description "es import";
        uses L2VPN-RT-ES-IMPORT;
      }  // container es-import

      leaf rt {
        type L2vpn-ad-rt;
        description "RT";
      }
    }  // grouping L2VPN-RT

    grouping L2VPN-XC-DISCO {
      description "L2VPN XC DISCO";
      container rd-value {
        description "Route Distinguisher";
        uses L2VPN-RD;
      }  // container rd-value

      leaf ad-method {
        type uint32;
        description "Autodiscovery Method";
      }

      leaf vpn-added {
        type boolean;
        description "VPN Added";
      }

      leaf ad-service-connected {
        type boolean;
        description "Service Connected";
      }

      leaf ad-signalling-method {
        type uint32;
        description "Signaling Protocol";
      }

      leaf ce-range {
        type uint16;
        description "CE Range";
      }

      leaf export-route-policy {
        type string;
        description "Export Route Policy";
      }

      leaf number-a-cs-up {
        type uint32;
        description
          "Number of attachment circuits up";
      }

      leaf number-p-ws-up {
        type uint32;
        description
          "Number of pseudowires up";
      }

      leaf number-ce2ce-advertised {
        type uint32;
        description
          "Number of ce2ce Advertised";
      }

      leaf number-a-cs {
        type uint32;
        description
          "Number of attachment circuits";
      }

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

      leaf number-ce2c-es {
        type uint32;
        description "Number of ce2ce";
      }

      list import-rt {
        description "Import Route Targets";
        uses L2VPN-RT;
      }  // list import-rt

      list export-rt {
        description "Export Route Targets";
        uses L2VPN-RT;
      }  // list export-rt
    }  // grouping L2VPN-XC-DISCO

    grouping L2VPN-MP2MP-XC {
      description "L2VPN MP2MP XC";
      container discovery {
        description
          "l2vpn xc auto discovery info";
        uses L2VPN-XC-DISCO;
      }  // container discovery

      leaf group-name-xr {
        type string;
        description "Group name";
      }

      leaf mp2mp-name {
        type string;
        description "MP2MP name";
      }

      leaf mp2mpid {
        type uint32;
        description "Identification Number";
      }

      leaf vpn-id {
        type uint32;
        description "Vpn ID";
      }

      leaf vpn-mtu {
        type uint32;
        description "VPN MTU";
      }

      leaf l2-encapsulation {
        type L2vpn-bag-ad-encap;
        description "L2 Encapsulation";
      }

      leaf xconnect-shutdown {
        type boolean;
        description
          "Administratively disabled";
      }
    }  // grouping L2VPN-MP2MP-XC

    grouping L2VPN-GROUP {
      description "L2VPN GROUP";
      leaf group-name-xr {
        type string;
        description "Group name";
      }

      leaf number-xconnects {
        type uint32;
        description "Number of xconnects";
      }
    }  // grouping L2VPN-GROUP

    grouping L2VPN-XC-CE2CE {
      description "L2VPN XC CE2CE";
      leaf local-customer-edge-id {
        type uint16;
        description "Local CE ID";
      }

      leaf remote-customer-edge-id {
        type uint16;
        description "Remote CE ID";
      }

      leaf ce-added {
        type boolean;
        description "CE2CE Advertised";
      }
    }  // grouping L2VPN-XC-CE2CE

    grouping L2VPN-P2MP-PW {
      description "L2VPN P2MP PW";
      leaf local-available {
        type boolean;
        description
          "Local LSM info available";
      }

      leaf local-label {
        type uint32;
        description "Local Label";
      }

      leaf local-ptree-type {
        type L2vpn-p2mp-pw-ptree;
        description "Local P-Tree Type";
      }

      leaf local-tunnel-id {
        type uint32;
        description "Local Tunnel ID";
      }

      leaf local-extended-tunnel-id {
        type inet:ipv4-address;
        description
          "Local Extended Tunnel ID";
      }

      leaf local-p2mp-id {
        type uint32;
        description "Local P2MP ID";
      }

      leaf local-flags {
        type uint8;
        description
          "Local Flags (see
         draft-ietf-l3vpn-2547bis-mcast-bgp-08)";
      }

      leaf remote-available {
        type boolean;
        description
          "Remote LSM info available";
      }

      leaf remote-label {
        type uint32;
        description "Remote Label";
      }

      leaf remote-ptree-type {
        type L2vpn-p2mp-pw-ptree;
        description "Remote P-Tree Type";
      }

      leaf remote-tunnel-id {
        type uint32;
        description "Remote Tunnel ID";
      }

      leaf remote-extended-tunnel-id {
        type inet:ipv4-address;
        description
          "Remote Extended Tunnel ID";
      }

      leaf remote-p2mp-id {
        type uint32;
        description "Remote P2MP ID";
      }

      leaf remote-flags {
        type uint8;
        description
          "Remote Flags (see
         draft-ietf-l3vpn-2547bis-mcast-bgp-08)";
      }
    }  // grouping L2VPN-P2MP-PW

    grouping L2VPN-MS-PW-TLV-INFO {
      description "L2VPN MS PW TLV INFO";
      leaf pw-id {
        type uint32;
        description
          "PW ID of last PW segment traversed";
      }

      leaf local-address {
        type inet:ipv4-address;
        description
          "Local IP Address of PW Switching Point";
      }

      leaf remote-address {
        type inet:ipv4-address;
        description
          "Remote IP Address of Last PW Switching Point
         traversed";
      }

      leaf description {
        type string;
        description
          "PW Switching Point description";
      }
    }  // grouping L2VPN-MS-PW-TLV-INFO

    grouping L2VPN-MS-PW {
      description "L2VPN MS PW";
      container status-tlv {
        description
          "PW Status Switching TLV";
        uses L2VPN-MS-PW-TLV-INFO;
      }  // container status-tlv

      leaf pw-status {
        type uint32;
        description "PW Status";
      }

      list tlv {
        description "Switching TLV info";
        uses L2VPN-MS-PW-TLV-INFO;
      }  // list tlv
    }  // grouping L2VPN-MS-PW

    grouping L2VPN-TE-NAMED-TUN-PREFPATH {
      description
        "L2VPN TE NAMED TUN PREFPATH";
      leaf te-named-tunnel {
        type string;
        description "TE Tunnel Name";
      }
    }  // grouping L2VPN-TE-NAMED-TUN-PREFPATH

    grouping L2VPN-SR-TE-PREFPATH {
      description "L2VPN SR TE PREFPATH";
      leaf policy-name {
        type string;
        description "SR TE Policy Name";
      }

      leaf policy-ifh {
        type uint32;
        description "SR TE Policy IFHandle";
      }

      leaf policy-bsid {
        type uint32;
        description
          "SR TE Policy Binding-SID";
      }
    }  // grouping L2VPN-SR-TE-PREFPATH

    grouping L2VPN-PW-MPLS-PREFPATH {
      description "L2VPN PW MPLS PREFPATH";
      container srte-policy {
        when
          "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
          description
            "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
        }
        description "srte policy";
        uses L2VPN-SR-TE-PREFPATH;
      }  // container srte-policy

      container te-named-tunnel {
        when
          "../option = 'l2vpn-pw-mpls-pref-path-te-named-tunnel'" {
          description
            "../Option =
           'L2VPN_PW_MPLS_PREFPATH_TE_NAMED_TUNNEL'";
        }
        description "te named tunnel";
        uses L2VPN-TE-NAMED-TUN-PREFPATH;
      }  // container te-named-tunnel

      leaf option {
        type L2vpn-prefpath-option;
        description "Option";
      }

      leaf next-hop-ip {
        when
          "../option = 'l2vpn-pw-mpls-pref-path-next-hop-ip'" {
          description
            "../Option =
           'L2VPN_PW_MPLS_PREFPATH_NEXT_HOP_IP'";
        }
        type uint32;
        description "NextHopIP";
      }

      leaf te-tunnel-interface-number {
        when
          "../option = 'l2vpn-pw-mpls-pref-path-te-tunnel'" {
          description
            "../Option = 'L2VPN_PW_MPLS_PREFPATH_TE_TUNNEL'";
        }
        type uint32;
        description
          "TETunnelInterfaceNumber";
      }

      leaf ip-tunnel-interface-number {
        when
          "../option = 'l2vpn-pw-mpls-pref-path-ip-tunnel'" {
          description
            "../Option = 'L2VPN_PW_MPLS_PREFPATH_IP_TUNNEL'";
        }
        type uint32;
        description
          "IPTunnelInterfaceNumber";
      }

      leaf tp-tunnel-interface-number {
        when
          "../option = 'l2vpn-pw-mpls-pref-path-tp-tunnel'" {
          description
            "../Option = 'L2VPN_PW_MPLS_PREFPATH_TP_TUNNEL'";
        }
        type uint32;
        description
          "TPTunnelInterfaceNumber";
      }
    }  // grouping L2VPN-PW-MPLS-PREFPATH

    grouping L2VPN-EVPN-L2-ATTRS {
      description "L2VPN EVPN L2 ATTRS";
      leaf mtu {
        type uint16;
        description
          "Maximum Transmission Unit";
      }

      leaf designated-forwarder-role {
        type Evpn-bag-df-role;
        description
          "Designated Forwarder Role";
      }

      leaf control-word {
        type Evpn-bag-l2-attr-cw;
        description "Control Word";
      }
    }  // grouping L2VPN-EVPN-L2-ATTRS

    grouping L2VPN-EVPN-SRV6-SID-INFO {
      description
        "SRv6 SID information for EVPN services";
      leaf srv6-sid {
        type inet:ipv6-address;
        description "SRv6 SID";
      }
    }  // grouping L2VPN-EVPN-SRV6-SID-INFO

    grouping L2VPN-EVPN-SRTE-INFO {
      description "L2VPN EVPN SRTE INFO";
      leaf sr-te-type {
        type uint8;
        description
          "Type of SR-TE Policy path from ODN";
      }

      leaf sr-te-interface-name {
        type xr:Interface-name;
        description
          "SR Traffic Engineering Interface Name";
      }

      leaf sr-te-bsid {
        type uint32;
        description
          "SR Traffic Engineering Binding-SID (Label)";
      }

      leaf srv6-te-bsid {
        type inet:ipv6-address;
        description
          "SRv6 Traffic Engineering Binding-SID";
      }
    }  // grouping L2VPN-EVPN-SRTE-INFO

    grouping L2VPN-LABEL-PATH-BUFFER {
      description "L2VPN LABEL PATH BUFFER";
      container sr-te-info {
        description
          "SR(v6)-TE Policy info from ODN";
        uses L2VPN-EVPN-SRTE-INFO;
      }  // container sr-te-info

      container layer2-attributes {
        description "Layer 2 Attributes";
        uses L2VPN-EVPN-L2-ATTRS;
      }  // container layer2-attributes

      leaf tunnel-endpoint-id {
        type uint32;
        description
          "Tunnel Endpoint Identifier";
      }

      leaf next-hop {
        type inet:ipv6-address;
        description
          "Next-hop IP address (v6 format)";
      }

      leaf output-label {
        type uint32;
        description "Output Label";
      }

      leaf reroute-label {
        type uint32;
        description "Reroute Label";
      }

      list issue {
        description
          "Issues with this path item";
        leaf entry {
          type Evpn-bag-path-issues;
          description
            "Issues with this path item";
        }
      }  // list issue

      list srv6-sid-info {
        description
          "Array of SRv6 SID information";
        uses L2VPN-EVPN-SRV6-SID-INFO;
      }  // list srv6-sid-info
    }  // grouping L2VPN-LABEL-PATH-BUFFER

    grouping MGMT-SRV6-ENDPOINT-BEHAVIOR {
      description
        "SRv6 Endpoint Behavior Info";
      leaf type {
        type Mgmt-srv6-endpoint;
        description "Behavior type";
      }

      leaf description {
        type string;
        description "Behavior description";
      }
    }  // grouping MGMT-SRV6-ENDPOINT-BEHAVIOR

    grouping MGMT-SRV6-HEADEND-BEHAVIOR {
      description
        "SRv6 Headend Behavior Info";
      leaf type {
        type Mgmt-srv6-headend;
        description "Behavior type";
      }

      leaf description {
        type string;
        description "Behavior description";
      }
    }  // grouping MGMT-SRV6-HEADEND-BEHAVIOR

    grouping L2VPN-SRV6 {
      description "L2VPN SRV6";
      container srv6-headend-behavior {
        description
          "Headend behavior in use";
        uses MGMT-SRV6-HEADEND-BEHAVIOR;
      }  // container srv6-headend-behavior

      container srv6-endpoint-behavior {
        description
          "Endpoint behavior in use";
        uses MGMT-SRV6-ENDPOINT-BEHAVIOR;
      }  // container srv6-endpoint-behavior

      leaf srv6-local-sid {
        type inet:ipv6-address;
        description
          "Locally allocated SRv6 SID";
      }

      leaf srv6-locator-name {
        type string;
        description
          "Locator Name used for allocation";
      }

      list remote-path-buffer {
        description
          "Remote path buffer containing remote SIDs";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list remote-path-buffer
    }  // grouping L2VPN-SRV6

    grouping L2VPN-L2TPV3 {
      description "L2VPN L2TPV3";
      leaf l2tp-class-name {
        type string {
          length "0..32";
        }
        description "L2TPClassName";
      }

      leaf ipv4-source-address {
        type inet:ipv4-address;
        description "IPv4 source address";
      }

      leaf ipv6-source-address {
        type inet:ipv6-address;
        description "IPv6 source address";
      }

      leaf path-mtu-enabled {
        type boolean;
        description "Path MTU enabled";
      }

      leaf path-mtu-max-value {
        type uint16;
        description
          "Path MTU Maximum allowable session MTU";
      }

      leaf dont-fragment-bit {
        type boolean;
        description "Don't Fragment Bit";
      }

      leaf tos-mode {
        type L2vpn-tos-mode;
        description "Type Of Service Mode";
      }

      leaf tos {
        type uint8;
        description "Type Of Service Value";
      }

      leaf ttl {
        type uint8;
        description "Time To Live value";
      }

      leaf local-session-id {
        type uint32;
        description "Local session id";
      }

      leaf remote-session-id {
        type uint32;
        description "Remote session id";
      }

      leaf local-cookie-size {
        type uint8;
        description
          "Local cookie size: 0, 4, or 8 bytes";
      }

      leaf remote-cookie-size {
        type uint8;
        description
          "Remote cookie size: 0, 4, or 8 bytes";
      }

      leaf local-cookie-low-value {
        type uint32;
        description
          "Lower 4 bytes of the value of the local cookie";
      }

      leaf remote-cookie-low-value {
        type uint32;
        description
          "Lower 4 bytes of the value of the remote cookie";
      }

      leaf local-cookie-high-value {
        type uint32;
        description
          "Upper 4 bytes of the value of the local cookie";
      }

      leaf remote-cookie-high-value {
        type uint32;
        description
          "Upper 4 bytes of the value of the remote cookie";
      }

      leaf remote-circuit-status-up {
        type boolean;
        description "RemoteCircuitStatusUp";
      }

      leaf tunnel-state {
        type L2vpn-l2tp-tunnel-state;
        description "L2TP tunnel state";
      }

      leaf local-secondary-cookie-size {
        type uint8;
        description
          "Local secondary cookie size: 0, 4, or 8 bytes";
      }

      leaf local-secondary-cookie-low-value {
        type uint32;
        description
          "Lower 4 bytes of the value of the local
         secondary cookie";
      }

      leaf local-secondary-cookie-high-value {
        type uint32;
        description
          "Upper 4 bytes of the value of the local
         secondary cookie";
      }
    }  // grouping L2VPN-L2TPV3

    grouping L2FIB-STATS-BAG-MSPW {
      description
        "L2FIB Multisegment pseudowire statistics";
      leaf received-packets {
        type uint64;
        description "Packets received";
      }

      leaf received-bytes {
        type uint64;
        units "byte";
        description "Bytes received";
      }
    }  // grouping L2FIB-STATS-BAG-MSPW

    grouping L2VPN-ATOM {
      description "L2VPN ATOM";
      container local-agi {
        description
          "Local Attachment Group Identifier";
        uses L2VPN-VPLS-ID;
      }  // container local-agi

      container remote-agi {
        description
          "Remote Attachment Group Identifier";
        uses L2VPN-VPLS-ID;
      }  // container remote-agi

      container multi-segment-pseudowire-stats {
        description
          "Multisegment pseudowire statistics";
        uses L2FIB-STATS-BAG-MSPW;
      }  // container multi-segment-pseudowire-stats

      leaf is-pseudowire-headend {
        type boolean;
        description
          "Is this connected to a PW-HE AC";
      }

      leaf local-label {
        type uint32;
        description "Local label";
      }

      leaf remote-label {
        type uint32;
        description "Remote label";
      }

      leaf local-group-id {
        type uint32;
        description "Local group ID";
      }

      leaf remote-group-id {
        type uint32;
        description "Remote group ID";
      }

      leaf local-cv-type {
        type uint8;
        description "Local VCCV CV type";
      }

      leaf local-c-ctype {
        type uint8;
        description "Local VCCV CC type";
      }

      leaf remote-cv-type {
        type uint8;
        description "Remote VCCV CV type";
      }

      leaf remote-c-ctype {
        type uint8;
        description "Remote VCCV CC type";
      }

      leaf local-veid {
        type uint32;
        description "Local VE ID";
      }

      leaf remote-veid {
        type uint32;
        description "Remote VE ID";
      }

      leaf local-ceid {
        type uint32;
        description "Local CE ID";
      }

      leaf remote-ceid {
        type uint32;
        description "Remote CE ID";
      }

      leaf source-address {
        type inet:ipv4-address;
        description
          "Local BGP source address";
      }

      leaf remote-source-address {
        type inet:ipv4-address;
        description
          "Remote BGP source address";
      }

      leaf local-ldp-id {
        type inet:ipv4-address;
        description "Local LDP ID";
      }

      leaf remote-ldp-id {
        type inet:ipv4-address;
        description "Remote LDP ID";
      }

      leaf saii {
        type inet:ipv4-address;
        description
          "Source Attachment Individual Identifer";
      }

      leaf taii {
        type inet:ipv4-address;
        description
          "Target Attachment Individual Identifer";
      }

      leaf is-sai-itype2 {
        type boolean;
        description "Is SAII FEC129 Type 2";
      }

      leaf local-saii-gbl-id {
        type uint32;
        description "Local SAII Global ID";
      }

      leaf local-saiiac-id {
        type uint32;
        description "Local SAII AC ID";
      }

      leaf is-tai-itype2 {
        type boolean;
        description "Is TAII type 2";
      }

      leaf local-taii-gbl-id {
        type uint32;
        description "Local TAII Global ID";
      }

      leaf local-taiiac-id {
        type uint32;
        description "Local TAII AC ID";
      }

      leaf rem-saii-gbl-id {
        type uint32;
        description "Remote SAII Global ID";
      }

      leaf rem-saiiac-id {
        type uint32;
        description "Remote SAII AC ID";
      }

      leaf rem-taii-gbl-id {
        type uint32;
        description "Remote TAII Global ID";
      }

      leaf rem-taiiac-id {
        type uint32;
        description "Remote TAII AC ID";
      }

      leaf rem-saii {
        type inet:ipv4-address;
        description
          "Remote Source Attachment Individual Identifer";
      }

      leaf rem-taii {
        type inet:ipv4-address;
        description
          "Remote Target Attachment Individual Identifer";
      }

      leaf lsd-rewrite-failed {
        type boolean;
        description "LSD rewrite failed";
      }

      leaf ldp-label-advertisment-failed {
        type boolean;
        description
          "LDP label advertisment failed";
      }

      leaf pwhe-internal-label {
        type uint32;
        description "PWHE Internal Label";
      }
    }  // grouping L2VPN-ATOM

    grouping L2VPN-ENCAP-PW {
      description "L2VPN ENCAP PW";
      container atom {
        when
          "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
          description
            "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
        }
        description "atom";
        uses L2VPN-ATOM;
      }  // container atom

      container l2tpv3 {
        when
          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
          description
            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
        }
        description "l2tpv3";
        uses L2VPN-L2TPV3;
      }  // container l2tpv3

      container srv6 {
        when
          "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
          description
            "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
        }
        description "srv6";
        uses L2VPN-SRV6;
      }  // container srv6

      leaf encapsulation {
        type L2vpn-encap-method;
        description "Encapsulation";
      }
    }  // grouping L2VPN-ENCAP-PW

    grouping L2VPN-PEER {
      description "L2VPN PEER";
      leaf type {
        type L2vpn-peer;
        description "type";
      }

      leaf ipv4-peer-id {
        when "../type = 'ipv4'" {
          description "../type = 'IPV4'";
        }
        type inet:ipv4-address;
        description "Peer IPv4 address";
      }

      leaf ipv6-peer-id {
        when "../type = 'ipv6'" {
          description "../type = 'IPV6'";
        }
        type L2vpn-bag-in6-addr;
        description "Peer IPv6 address";
      }

      leaf internal-label {
        when "../type = 'internal-label'" {
          description
            "../type = 'InternalLabel'";
        }
        type uint32;
        description "Internal Label";
      }

      leaf internal-id {
        when "../type = 'internal-id'" {
          description
            "../type = 'InternalID'";
        }
        type uint32;
        description "Internal ID";
      }
    }  // grouping L2VPN-PEER

    grouping L2VPN-PW {
      description "L2VPN PW";
      container peer-id {
        description "Peer";
        uses L2VPN-PEER;
      }  // container peer-id

      container encapsulation-info {
        description
          "Encapsulation specific pseudowire information";
        uses L2VPN-ENCAP-PW;
      }  // container encapsulation-info

      container local-interface {
        description "Local interface";
        uses L2VPN-INTERFACE;
      }  // container local-interface

      container remote-interface {
        description "Remote interface";
        uses L2VPN-INTERFACE;
      }  // container remote-interface

      container preferred-path {
        description "MPLS Preferred Path";
        uses L2VPN-PW-MPLS-PREFPATH;
      }  // container preferred-path

      container local-signalling {
        description "Local signalling";
        uses L2VPN-MS-PW;
      }  // container local-signalling

      container remote-signalling {
        description "Remote signalling";
        uses L2VPN-MS-PW;
      }  // container remote-signalling

      container statistics {
        description "Statistics";
        uses L2FIB-STATS-BAG-FORWARDING;
      }  // container statistics

      container p2mp-pw {
        description
          "P2MP Pseudowire Information";
        uses L2VPN-P2MP-PW;
      }  // container p2mp-pw

      leaf local-source-address {
        type inet:ipv4-address;
        description "Local Source Address";
      }

      leaf ipv6-local-source-address {
        type inet:ipv6-address;
        description
          "Local IPv6 Source Address";
      }

      leaf pseudo-wire-id {
        type uint64;
        description "Pseudowire ID";
      }

      leaf evpn-vpws-type {
        type Evpn-vpws;
        description "EVPN VPWS Type";
      }

      leaf is-pwr-type {
        type boolean;
        description "is Pseudowire-routed";
      }

      leaf is-evpn-vpws-type {
        type boolean;
        description "is EVPN VPWS";
      }

      leaf xconnect-id {
        type uint32;
        description "XConnect ID";
      }

      leaf state {
        type L2vpn-segment-state;
        description "State";
      }

      leaf pseudo-wire-state {
        type L2vpn-pw-state;
        description "Pseudowire state";
      }

      leaf protocol {
        type L2vpn-signalling-proto;
        description "Protocol";
      }

      leaf pw-class-name {
        type string {
          length "0..33";
        }
        description "Pseudowire class name";
      }

      leaf tag-rewrite {
        type uint16;
        description "StaticTagRewrite";
      }

      leaf interworking {
        type L2vpn-interworking;
        description "Interworking type";
      }

      leaf fe-ctype {
        type L2vpn-pw-fec;
        description "Pseudowire FEC type";
      }

      leaf evpn-src-acid {
        type uint32;
        description "EVPN VPWS Source AC ID";
      }

      leaf mtu-mismatch-ignore {
        type boolean;
        description "Ignore MTU Mismatch";
      }

      leaf mtu-zero-transmit {
        type boolean;
        description "Transmit MTU Zero";
      }

      leaf sequencing-type {
        type L2vpn-pw-sequence;
        description "Sequencing Type";
      }

      leaf resync-enabled {
        type boolean;
        description
          "Resync if packets out of sequence";
      }

      leaf resync-threshold {
        type uint32;
        description
          "Number of Packets Out of Seqence to trigger
         resync";
      }

      leaf local-control-word {
        type L2vpn-pw-control-word;
        description "Local control word";
      }

      leaf remote-control-word {
        type L2vpn-pw-control-word;
        description "Remote control word";
      }

      leaf local-pseudo-wire-type {
        type L2vpn-pw;
        description "Local pseudowire type";
      }

      leaf remote-pseudo-wire-type {
        type L2vpn-pw;
        description "Remote pseudowire type";
      }

      leaf imposed-vlan-id {
        type uint32;
        description "Imposed vlan id";
      }

      leaf time-created {
        type string {
          length "0..50";
        }
        description
          "Time when the pseudowire was created";
      }

      leaf time-elapsed-creation {
        type string {
          length "0..50";
        }
        description
          "Time elapsed since creation";
      }

      leaf last-time-status-changed {
        type string {
          length "0..50";
        }
        description
          "Last time the pseudowire status changed";
      }

      leaf time-elapsed-status-changed {
        type string {
          length "0..50";
        }
        description
          "Time elapsed since status changed";
      }

      leaf last-time-status-down {
        type string {
          length "0..50";
        }
        description
          "Last time the pseudowire went down in format
         %d/%m/%Y %H:%M:%S";
      }

      leaf time-elapsed-status-down {
        type uint32;
        units "second";
        description
          "Time elapsed since last status down in seconds";
      }

      leaf shutdown {
        type boolean;
        description "Shutdown";
      }

      leaf data-path-down {
        type boolean;
        description "True if LSP down";
      }

      leaf use-tunnel-path {
        type boolean;
        description
          "True if using TE tunnel";
      }

      leaf odn-configured {
        type boolean;
        description
          "True if ODN is configured";
      }

      leaf pseudo-wire-type-mismatched {
        type boolean;
        description
          "Pseudowire type mismatched";
      }

      leaf payload-bytes-mismatched {
        type boolean;
        description
          "Payload bytes mismatched";
      }

      leaf bitrate-mismatched {
        type boolean;
        description "Bitrate mismatched";
      }

      leaf rtp-mismatched {
        type boolean;
        description "RTP mismatched";
      }

      leaf diff-ts-mismatched {
        type boolean;
        description
          "Differential timestamp mismatched";
      }

      leaf sig-pkts-mismatched {
        type boolean;
        description
          "Signalling packets mismatched";
      }

      leaf cas-mismatched {
        type boolean;
        description "CAS mismatched";
      }

      leaf payload-type-mismatched {
        type boolean;
        description
          "Payload bytes mismatched";
      }

      leaf freq-mismatched {
        type boolean;
        description "Frequency mismatched";
      }

      leaf ssrc-mismatched {
        type boolean;
        description "SSRC mismatched";
      }

      leaf mtu-mismatched {
        type boolean;
        description "MTU mismatched";
      }

      leaf illegal-control-word {
        type boolean;
        description "Illegal control word";
      }

      leaf ad-remote-down {
        type boolean;
        description
          "Auto-Discovered PW remote state down";
      }

      leaf not-supported-qinq {
        type boolean;
        description
          "A true value indicates that QinQ is not
         supported with L2TPv3; A false value indicates
         that it is supported. Please note that this
         object has been deprecated and will be removed
         in the near future since QinQ is supported going
         forward.";
      }

      leaf local-label-failed {
        type boolean;
        description
          "Failed to set BGP advertised local label";
      }

      leaf remote-label-failed {
        type boolean;
        description
          "Failed to set BGP advertised remote label";
      }

      leaf preferred-path-disable-fallback {
        type boolean;
        description
          "Prefpath fallback enable/disable";
      }

      leaf backup-pw {
        type boolean;
        description
          "TRUE if PW is a backup PW";
      }

      leaf primary-pw {
        type boolean;
        description
          "TRUE if PW is a primary PW";
      }

      leaf backup-active {
        type boolean;
        description
          "TRUE if backup is active";
      }

      leaf backup-force-active {
        type boolean;
        description
          "TRUE if backup is active due to switchover";
      }

      leaf disable-never {
        type boolean;
        description
          "TRUE if backup is not automatically disabled";
      }

      leaf disable-delay {
        type uint8;
        description "Backup disable delay";
      }

      leaf primary-peer-id {
        type inet:ipv4-address;
        description
          "Primary Peer IP address";
      }

      leaf primary-pseudo-wire-id {
        type uint64;
        description "Primary Pseudowire ID";
      }

      leaf number-ma-cwithdraw-message-sent {
        type uint32;
        description
          "Num MW messages sent over PW";
      }

      leaf num-ma-cwithdraw-msg-received {
        type uint32;
        description
          "Num MW messages received over PW";
      }

      leaf out-of-memory-state {
        type uint32;
        description
          "L2VPN Out of memory state";
      }

      leaf transport-lsp-down {
        type boolean;
        description
          "Oper down due to Transport LSP down";
      }

      leaf mac-limit-oper-down {
        type boolean;
        description
          "Oper down because MAC limit reached";
      }

      leaf pw-status-use {
        type boolean;
        description "PW status in use";
      }

      leaf auto-discovery {
        type boolean;
        description "Is autodiscovery";
      }

      leaf ad-method {
        type uint32;
        description "Autodiscovery method";
      }

      leaf pwlsd-rewrite-failed {
        type boolean;
        description "LSD rewrite failed";
      }

      leaf ldp-label-advertise-failed {
        type boolean;
        description
          "LDP label advertisment failed";
      }

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

      leaf is-multi-segment-pseudowire {
        type boolean;
        description
          "Is Multi-Segment Pseudowire";
      }

      leaf pw-redundancy-one-way {
        type boolean;
        description
          "Force one-way PW redundancy behaviour in
         Redundancy Group";
      }

      leaf load-balance {
        type L2vpn-load-bal;
        description "Load Balance Type";
      }

      leaf pw-flow-label-type {
        type L2vpn-pw-flow-label;
        description
          "Negotiated pseudowire flow label type";
      }

      leaf pw-flow-label-type-cfg {
        type L2vpn-pw-flow-label;
        description
          "Configured pseudowire flow label Type";
      }

      leaf pw-flow-label-code17-disabled {
        type boolean;
        description
          "Disable sending Code 17 TLV";
      }

      leaf is-flow-label-static {
        type boolean;
        description "is flow label static";
      }

      leaf is-partially-programmed {
        type boolean;
        description
          "Is Pseudowire partially programmed";
      }

      leaf pw-redundancy-initial-delay {
        type uint8;
        units "second";
        description
          "Initial delay for redundant PW in seconds";
      }

      leaf bridge-pw-type-mismatch {
        type boolean;
        description
          "Oper down because Bridge has mismatched PW Types";
      }

      leaf required-bw {
        type uint32;
        description "Required Bandwidth";
      }

      leaf admited-bw {
        type uint32;
        description "Admited Bandwidth";
      }

      leaf forward-class {
        type uint8;
        description
          "Forward Class attribute";
      }

      leaf table-policy-name {
        type string;
        description "Table-policy Name";
      }

      leaf is-fxc-vlan-aware {
        type boolean;
        description "Is FXC vlan-aware";
      }

      list evpn-vpws-down-reason {
        description "EVPN VPWS down reasons";
        leaf entry {
          type Evpn-vpws-reason;
          description
            "EVPN VPWS down reasons";
        }
      }  // list evpn-vpws-down-reason
    }  // grouping L2VPN-PW

    grouping L2VPN-PROTECTION {
      description "L2VPN PROTECTION";
      leaf protection-type {
        type L2vpn-protection;
        description "Type of the protection";
      }

      leaf protection-configured {
        type L2vpn-protection-role;
        description "Protection configured";
      }

      leaf protection-name {
        type string {
          length "0..65";
        }
        description
          "Name of the segment acting as backup";
      }

      leaf protected-name {
        type string {
          length "0..65";
        }
        description
          "Name of the protected segment";
      }

      leaf active {
        type boolean;
        description "Active";
      }
    }  // grouping L2VPN-PROTECTION

    grouping L2FIB-STATS-BAG-SEQ-NUM {
      description "L2FIB sequence numbers";
      leaf sequence-number-sent {
        type uint32;
        description "sequence number sent";
      }

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

      leaf bypassed-inbound-sequence-packet {
        type uint64;
        description
          "Bypassed inbound sequence packets";
      }

      leaf bypassed-out-sequence-packet {
        type uint64;
        description
          "Bypassed outbound sequence packets";
      }
    }  // grouping L2FIB-STATS-BAG-SEQ-NUM

    grouping L2FIB-STATS-BAG-DISP {
      description
        "L2FIB disposition statistics";
      container disposition-stat {
        description "disposition stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container disposition-stat

      container disposition-mtu-drop {
        description
          "disposition mtu drop stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container disposition-mtu-drop

      container disposition-tail-drop {
        description
          "disposition tail drop stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container disposition-tail-drop

      container multicast-drop {
        description
          "disposition storm control multicast drop stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container multicast-drop

      container unicast-drop {
        description
          "disposition storm control unknown unicast drop
         stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container unicast-drop

      container broadcast-drop {
        description
          "disposition storm control broadcast drop stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container broadcast-drop

      container received-drops {
        description "tx discards";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container received-drops

      container dai-drop {
        description
          "Disposition dynamic ARP inspection drop
         statistics";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container dai-drop

      container ipsg-drop {
        description
          "disposition IP source guard drop statistics";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container ipsg-drop

      container disposition-oo-o-drops {
        description
          "Disposition Out-of-Order Drops";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container disposition-oo-o-drops

      container disposition-p2mp-stats {
        description "Disposition P2MP Stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container disposition-p2mp-stats

      container known-unicast {
        description "Known Unicast";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container known-unicast

      container mac-move {
        description "MAC Move";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container mac-move
    }  // grouping L2FIB-STATS-BAG-DISP

    grouping L2FIB-STATS-BAG-COUNTERS {
      description
        "L2FIB statistics counters";
      leaf packet-counts {
        type uint64;
        description "packets counters";
      }

      leaf byte-counts {
        type uint64;
        units "byte";
        description "bytes counters";
      }
    }  // grouping L2FIB-STATS-BAG-COUNTERS

    grouping L2FIB-STATS-BAG-IMP {
      description
        "L2FIB imposition statistics";
      container imposition-stat {
        description "imposition stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container imposition-stat

      container imposition-mtu-drop {
        description
          "imposition mtu drop stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container imposition-mtu-drop

      container imposition-tail-drop {
        description
          "imposition tail drop stats";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container imposition-tail-drop

      container l2fsbi-drop {
        description "rx discards";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container l2fsbi-drop

      container multicast {
        description "Multicast";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container multicast

      container broadcast {
        description "Broadcast";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container broadcast

      container known-unicast {
        description "Known Unicast";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container known-unicast

      container unknown-unicast {
        description "Unknown Unicast";
        uses L2FIB-STATS-BAG-COUNTERS;
      }  // container unknown-unicast
    }  // grouping L2FIB-STATS-BAG-IMP

    grouping L2FIB-STATS-BAG-FORWARDING {
      description
        "L2FIB forwarding statistics";
      container imposition-stats {
        description "imposition stats";
        uses L2FIB-STATS-BAG-IMP;
      }  // container imposition-stats

      container disposition-stats {
        description "disposition stats";
        uses L2FIB-STATS-BAG-DISP;
      }  // container disposition-stats

      container sequence-number {
        description "sequence numbers";
        uses L2FIB-STATS-BAG-SEQ-NUM;
      }  // container sequence-number
    }  // grouping L2FIB-STATS-BAG-FORWARDING

    grouping L2VPN-PWHE {
      description "L2VPN PWHE";
      container interface-list {
        description "Interface list data";
        uses ITEM-IFLIST-IFL;
      }  // container interface-list

      leaf is-valid {
        type boolean;
        description
          "Is this Interface list valid";
      }

      leaf internal-label {
        type uint32;
        description "Internal Label";
      }
    }  // grouping L2VPN-PWHE

    grouping L2VPN-FR {
      description "L2VPN FR";
      leaf fr-mode {
        type L2vpn-fr-mode;
        description "Frame Relay mode";
      }

      leaf dlci {
        type uint32;
        description
          "Data-link connection identifier";
      }
    }  // grouping L2VPN-FR

    grouping L2VPN-ATM {
      description "L2VPN ATM";
      leaf maximum-number-cells-packed {
        type uint16;
        description
          "Max number of cells packed";
      }

      leaf maximum-number-cells-un-packed {
        type uint16;
        description
          "Max number of cells unpacked";
      }

      leaf atm-mode {
        type L2vpn-atm-mode;
        description "ATM mode";
      }

      leaf vpi {
        type uint16;
        description
          "Virtual path identifier";
      }

      leaf vci {
        type uint16;
        description
          "Virtual channel identifier";
      }
    }  // grouping L2VPN-ATM

    grouping L2VPN-TDM-OPTION {
      description "L2VPN TDM options";
      leaf payload-bytes {
        type uint16;
        units "byte";
        description "TDM payload bytes";
      }

      leaf bit-rate {
        type uint32;
        units "kbit/s";
        description
          "TDM bit rate in units of Kbps";
      }

      leaf rtp {
        type L2vpn-tdm-rtp-option;
        description "RTP header";
      }

      leaf timestamp-mode {
        type L2vpn-time-stamp-mode;
        description "TDM Timestamping mode";
      }

      leaf signalling-packets {
        type uint8;
        description "Signalling packets";
      }

      leaf cas {
        type uint8;
        description "CAS";
      }

      leaf rtp-header-payload-type {
        type uint8;
        description
          "RTP header payload type";
      }

      leaf timestamp-clock-freq {
        type uint16;
        description
          "Timestamping clock frequency in units of 8Khz";
      }

      leaf ssrc {
        type uint32;
        description
          "Synchronization Source identifier";
      }
    }  // grouping L2VPN-TDM-OPTION

    grouping L2VPN-TDM {
      description "L2VPN TDM parameters";
      container tdm-options {
        description "TDM options";
        uses L2VPN-TDM-OPTION;
      }  // container tdm-options

      leaf timeslot-group {
        type string;
        description
          "Timeslots separated by , or - from 1 to 31. :
         indicates individual timeslot and - represents a
         range.E.g. 1-3,5 represents timeslots 1, 2, 3,
         and 5.";
      }

      leaf timeslot-rate {
        type uint8;
        units "kbit/s";
        description
          "Timeslot rate in units of Kbps";
      }

      leaf tdm-mode {
        type L2vpn-tdm-mode;
        description "TDM mode";
      }
    }  // grouping L2VPN-TDM

    grouping L2VPN-EFP-RANGE {
      description "EFP range";
      leaf lower {
        type uint16;
        description "Lower";
      }

      leaf upper {
        type uint16;
        description "Upper";
      }
    }  // grouping L2VPN-EFP-RANGE

    grouping L2VPN-VLAN {
      description "L2VPN VLAN";
      leaf xconnect-tags {
        type uint8;
        description "XConnect tags";
      }

      leaf vlan-rewrite-tag {
        type uint16;
        description "VLAN rewrite tag";
      }

      leaf simple-efp {
        type uint8;
        description "Simple EFP";
      }

      leaf encapsulation-type {
        type uint8;
        description "Encapsulation Type";
      }

      leaf outer-tag {
        type uint16;
        description "Outer Tag";
      }

      list rewrite-tag {
        description "Rewrite Tags";
        leaf entry {
          type uint16;
          description "Rewrite Tags";
        }
      }  // list rewrite-tag

      list vlan-range {
        description "vlan range";
        uses L2VPN-EFP-RANGE;
      }  // list vlan-range
    }  // grouping L2VPN-VLAN

    grouping L2VPN-ETHERNET {
      description "L2VPN ETHERNET";
      leaf xconnect-tags {
        type uint8;
        description "XConnect tags";
      }
    }  // grouping L2VPN-ETHERNET

    grouping L2VPN-INTERFACE-PARAMS {
      description "L2VPN INTERFACE PARAMS";
      container ethernet {
        when
          "../type = 'l2vpn-intf-type-ethernet'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
        }
        description "Ethernet";
        uses L2VPN-ETHERNET;
      }  // container ethernet

      container vlan {
        when
          "../type = 'l2vpn-intf-type-vlan'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
        }
        description "VLAN";
        uses L2VPN-VLAN;
      }  // container vlan

      container tdm {
        when
          "../type = 'l2vpn-intf-type-cem'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_CEM'";
        }
        description "TDM";
        uses L2VPN-TDM;
      }  // container tdm

      container atm {
        when
          "../type = 'l2vpn-intf-type-atm'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_ATM'";
        }
        description "ATM";
        uses L2VPN-ATM;
      }  // container atm

      container fr {
        when
          "../type = 'l2vpn-intf-type-frame-relay'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
        }
        description "Frame Relay";
        uses L2VPN-FR;
      }  // container fr

      container pseudowire-ether {
        when
          "../type = 'l2vpn-intf-type-pw-ether'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
        }
        description "PW Ether";
        uses L2VPN-PWHE;
      }  // container pseudowire-ether

      container pseudowire-iw {
        when
          "../type = 'l2vpn-intf-type-pw-iw'" {
          description
            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
        }
        description "PW IW";
        uses L2VPN-PWHE;
      }  // container pseudowire-iw

      leaf type {
        type L2vpn-interface;
        description "Type";
      }
    }  // grouping L2VPN-INTERFACE-PARAMS

    grouping L2VPN-INTERFACE {
      description "L2VPN INTERFACE";
      container parameters {
        description "Interface parameters";
        uses L2VPN-INTERFACE-PARAMS;
      }  // container parameters

      leaf name {
        type string {
          length "0..81";
        }
        description "Interface name";
      }

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

      leaf payload-bytes {
        type uint16;
        units "byte";
        description "Payload bytes";
      }
    }  // grouping L2VPN-INTERFACE

    grouping L2VPN-AC {
      description "L2VPN AC";
      container interface {
        description "Interface";
        uses L2VPN-INTERFACE;
      }  // container interface

      container statistics {
        description "Statistics";
        uses L2FIB-STATS-BAG-FORWARDING;
      }  // container statistics

      container l2vpn-protection {
        description
          "Protection object used for this segment";
        uses L2VPN-PROTECTION;
      }  // container l2vpn-protection

      leaf state {
        type L2vpn-segment-state;
        description "State";
      }

      leaf msti {
        type string;
        description "MSTi";
      }

      leaf internal-ms-ti {
        type string;
        description "Internal MSTi";
      }

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

      leaf xconnect-id {
        type uint32;
        description "XConnect ID";
      }

      leaf ms-ti-mismatch {
        type boolean;
        description "MSTi mismatch";
      }

      leaf mtu-mismatched {
        type boolean;
        description "MTU mismatched";
      }

      leaf tdm-media-mismatched {
        type boolean;
        description
          "TDM media parms mismatched";
      }

      leaf bvi-mac-conflict {
        type boolean;
        description "BVI Mac Conflict";
      }

      leaf bvi-no-port-up {
        type boolean;
        description "BVI no BP Up";
      }

      leaf control-word-mismatched {
        type boolean;
        description
          "Control word mismatched";
      }

      leaf encapsulation-mismatched {
        type boolean;
        description
          "Encapsulation mismatched";
      }

      leaf encapsulation-error {
        type string;
        description "Encapsulation Error";
      }

      leaf interworking {
        type L2vpn-interworking;
        description "Interworking type";
      }

      leaf out-of-memory-state {
        type uint32;
        description
          "L2VPN Out of memory state";
      }

      leaf msti-mismatch-down {
        type boolean;
        description
          "Oper down due to MSTI mismatch";
      }

      leaf mac-limit-oper-down {
        type boolean;
        description
          "Oper down because MAC limit reached";
      }

      leaf redundancy-group-id {
        type uint32;
        description "Redundancy Group ID";
      }

      leaf redundancy-group-state {
        type L2vpn-rg-state;
        description "Redundancy Group State";
      }

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

      leaf is-ac-partially-programmed {
        type boolean;
        description
          "Is attachment-circuit partially programmed";
      }

      leaf evpn-internal-label {
        type uint32;
        description "EVPN Internal Label";
      }
    }  // grouping L2VPN-AC

    grouping L2VPN-SEGMENT {
      description "L2VPN SEGMENT";
      container attachment-circuit {
        when
          "../segment-type = 'l2vpn-segment-type-ac'" {
          description
            "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
        }
        description "Attachment Circuit";
        uses L2VPN-AC;
      }  // container attachment-circuit

      container pseudo-wire {
        when
          "../segment-type = 'l2vpn-segment-type-pw'" {
          description
            "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
        }
        description "Pseudowire";
        uses L2VPN-PW;
      }  // container pseudo-wire

      leaf segment-type {
        type L2vpn-segment;
        description "SegmentType";
      }
    }  // grouping L2VPN-SEGMENT

    grouping L2VPN-XC {
      description "L2VPN XC";
      container backup {
        description "LCR backup";
        uses L2VPN-SEGMENT;
      }  // container backup

      container segment1 {
        description "Segment 1";
        uses L2VPN-SEGMENT;
      }  // container segment1

      container segment2 {
        description "Segment 2";
        uses L2VPN-SEGMENT;
      }  // container segment2

      container ce2ce {
        description "CE2CE";
        uses L2VPN-XC-CE2CE;
      }  // container ce2ce

      leaf group-name-xr {
        type string;
        description "Group name";
      }

      leaf xconnect-name-xr {
        type string;
        description "XConnect name";
      }

      leaf number-of-backup-p-ws {
        type uint32;
        description "Number of backups";
      }

      leaf state {
        type L2vpn-xc-state;
        description "State of the xconnect";
      }

      leaf interworking {
        type L2vpn-interworking;
        description "Interworking type";
      }

      leaf diag-mask {
        type uint32;
        description
          "Mask indicating what if anything is missing
         before the XC can be provisioned";
      }

      leaf description {
        type string;
        description "P2P Description";
      }

      leaf is-mp2mp {
        type boolean;
        description "xconnect is mp2mp";
      }

      list backup-segment {
        max-elements 1;
        description "Backup Segment";
        uses L2VPN-SEGMENT;
      }  // list backup-segment
    }  // grouping L2VPN-XC

    grouping L2VPN-RD-V4ADDR {
      description "L2VPN RD V4ADDR";
      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPv4 Address";
      }

      leaf two-byte-index {
        type uint16;
        description "2 Byte Index";
      }
    }  // grouping L2VPN-RD-V4ADDR

    grouping L2VPN-RD-4BYTE-AS {
      description "L2VPN RD 4BYTE AS";
      leaf four-byte-as {
        type uint32;
        description "4 Byte AS Number";
      }

      leaf two-byte-index {
        type uint16;
        description "2 Byte Index";
      }
    }  // grouping L2VPN-RD-4BYTE-AS

    grouping L2VPN-RD-2BYTE-AS {
      description "L2VPN RD 2BYTE AS";
      leaf two-byte-as {
        type uint16;
        description "2 Byte AS Number";
      }

      leaf four-byte-index {
        type uint32;
        description "4 Byte Index";
      }
    }  // grouping L2VPN-RD-2BYTE-AS

    grouping L2VPN-RD-AUTO {
      description "L2VPN RD AUTO";
      leaf router-id {
        type inet:ipv4-address;
        description "BGP Router ID";
      }

      leaf auto-index {
        type uint16;
        description "Auto-generated Index";
      }
    }  // grouping L2VPN-RD-AUTO

    grouping L2VPN-RD {
      description "L2VPN RD";
      container auto {
        when "../rd = 'l2vpn-ad-rd-auto'" {
          description
            "../RD = 'L2VPN_AD_RD_AUTO'";
        }
        description "auto";
        uses L2VPN-RD-AUTO;
      }  // container auto

      container two-byte-as {
        when "../rd = 'l2vpn-ad-rd-as'" {
          description
            "../RD = 'L2VPN_AD_RD_AS'";
        }
        description "two byte as";
        uses L2VPN-RD-2BYTE-AS;
      }  // container two-byte-as

      container four-byte-as {
        when
          "../rd = 'l2vpn-ad-rd-4byte-as'" {
          description
            "../RD = 'L2VPN_AD_RD_4BYTE_AS'";
        }
        description "four byte as";
        uses L2VPN-RD-4BYTE-AS;
      }  // container four-byte-as

      container v4-addr {
        when "../rd = 'l2vpn-ad-rd-v4-addr'" {
          description
            "../RD = 'L2VPN_AD_RD_V4ADDR'";
        }
        description "v4 addr";
        uses L2VPN-RD-V4ADDR;
      }  // container v4-addr

      leaf rd {
        type L2vpn-ad-rd;
        description "RD";
      }
    }  // grouping L2VPN-RD

    grouping L2VPN-ATOM-PWR-SUMMARY {
      description
        "L2VPN ATOM Pseudowire Routing Information Summary";
      container rd-auto {
        description
          "Automatic Route Distingtuisher";
        uses L2VPN-RD;
      }  // container rd-auto

      container rd-configured {
        description
          "Configured Route Distinguisher";
        uses L2VPN-RD;
      }  // container rd-configured

      leaf bgp-router-id {
        type inet:ipv4-address;
        description "BGP Router ID";
      }

      leaf cfg-router-id {
        type inet:ipv4-address;
        description "Configured Router ID";
      }

      leaf bgp-as {
        type uint32;
        description "BGP AS number";
      }

      leaf cfg-global-id {
        type uint32;
        description "Configured Global ID";
      }

      leaf l2vpn-has-bgp-eod {
        type boolean;
        description "L2VPN got BGP EOD";
      }
    }  // grouping L2VPN-ATOM-PWR-SUMMARY

    grouping L2VPN-GLOBALS {
      description "L2VPN GLOBALS";
      leaf pw-grouping-enabled {
        type boolean;
        description "PW Grouping enabled";
      }

      leaf pw-status-enabled {
        type boolean;
        description "PW Status enabled";
      }

      leaf logging-pw-enabled {
        type boolean;
        description "Logging PW enabled";
      }

      leaf logging-bd-enabled {
        type boolean;
        description
          "Logging BD state changes enabled";
      }

      leaf logging-vfi-enabled {
        type boolean;
        description
          "Logging VFI state changes enabled";
      }

      leaf logging-nsr-enabled {
        type boolean;
        description
          "Logging NSR state changes enabled";
      }

      leaf logging-df-election-enabled {
        type boolean;
        description
          "Logging EVPN Designated Forwarder changes
         enabled";
      }

      leaf tcn-propagation-enabled {
        type boolean;
        description
          "TCN propagation enabled";
      }

      leaf pw-oam-refresh-transmit-time {
        type uint32;
        units "second";
        description
          "PW OAM refresh transmit (seconds)";
      }

      leaf ha-role {
        type string;
        description "Node redundancy role";
      }

      leaf issu-role {
        type string;
        description "Node ISSU role";
      }

      leaf process-fsm {
        type string;
        description "Current L2VPN FSM role";
      }

      leaf going-active {
        type boolean;
        description
          "transitioning to Active functional role";
      }
    }  // grouping L2VPN-GLOBALS

    grouping VC-INFO {
      description "VC Info";
      leaf peer-id {
        type inet:ipv4-address;
        description "PeerID";
      }

      leaf source-address {
        type inet:ipv4-address;
        description "SourceAddress";
      }

      leaf pwid-type {
        type L2vpn-pw-id;
        description "pwid type";
      }

      leaf pwid {
        type uint64;
        description "PWID";
      }

      leaf fe-ctype {
        type L2vpn-pw-fec;
        description "FECType";
      }
    }  // grouping VC-INFO

    grouping L2VPN-PREFERRED-PATH {
      description "L2VPN PREFRRED PATH";
      leaf type {
        type L2vpn-preferred;
        description "Preferred type";
      }

      leaf interface-name-xr {
        type string {
          length "0..65";
        }
        description "Interface name";
      }

      leaf total-bandwidth {
        type uint32;
        description "TotalBandwidth";
      }

      leaf available-bandwidth {
        type uint32;
        description "AvailableBandwidth";
      }

      leaf reserved-bandwidth {
        type uint32;
        description "ReservedBandwidth";
      }

      list virtual-circuit {
        description "virtual circuit";
        uses VC-INFO;
      }  // list virtual-circuit
    }  // grouping L2VPN-PREFERRED-PATH

    grouping L2VPN-MGMT-PROC-FSM-REPORT-CARD {
      description
        "L2VPN Process FSM report card";
      leaf collaborator-is-connected {
        type boolean;
        description
          "Is the collaborator connected";
      }

      leaf connection-change-time {
        type uint32;
        description
          "Time when connection state (UP/DOWN) changed";
      }

      leaf collaborator-idt-done {
        type boolean;
        description
          "Is IDT done for this collaborator";
      }

      leaf idt-time {
        type uint32;
        description "Time when IDT was done";
      }

      leaf collaborator-skipped {
        type boolean;
        description
          "Was this collaborator skipped for not connecting
         in time";
      }

      leaf expect-idt {
        type boolean;
        description
          "Does this collaborator expect an IDT";
      }
    }  // grouping L2VPN-MGMT-PROC-FSM-REPORT-CARD

    grouping L2VPN-IDT-STATUS {
      description "IDT status information";
      leaf sync-status {
        type L2vpn-sync-status;
        description "Sync status";
      }

      leaf not-ready-reason {
        type L2vpn-ha-nsr-not-ready-reason;
        description "Not ready reason";
      }

      leaf idt-start-time {
        type uint32;
        units "second";
        description
          "IDT start timestamp in seconds";
      }

      leaf idt-end-time {
        type uint32;
        units "second";
        description
          "IDT end timestamp in seconds";
      }

      leaf declare-time {
        type uint32;
        units "second";
        description
          "Declare ready timestamp in seconds";
      }

      leaf withdraw-time {
        type uint32;
        units "second";
        description
          "Withdraw ready timestamp in seconds";
      }
    }  // grouping L2VPN-IDT-STATUS

    grouping L2VPN-NSR-ISSU-STATUS-INFO {
      description
        "NSR/ISSU status information";
      container idt-status {
        description "IDT status";
        uses L2VPN-IDT-STATUS;
      }  // container idt-status

      container previ-ous-idt-status {
        description "Previous IDT status";
        uses L2VPN-IDT-STATUS;
      }  // container previ-ous-idt-status

      leaf nsr-role {
        type uint8;
        description "NSR role";
      }

      leaf issu-role {
        type uint8;
        description "ISSU role";
      }
    }  // grouping L2VPN-NSR-ISSU-STATUS-INFO

    grouping L2VPN-FAILOVER-STATUS {
      description "L2VPN failover status";
      leaf triggered-time {
        type uint32;
        description "Triggered time";
      }

      leaf start-time {
        type uint32;
        description "Start time";
      }

      leaf master-time {
        type uint32;
        description "Master time";
      }
    }  // grouping L2VPN-FAILOVER-STATUS

    grouping L2VPN-MGMT-PROC-FSM-XID-INFO {
      description
        "L2VPN MGMT PROC FSM XID INFO";
      leaf app-type {
        type L2vpn-id-mgr-app-bag;
        description "App type";
      }

      leaf sent-ids {
        type uint32;
        description
          "Number of XIDs transferred";
      }
    }  // grouping L2VPN-MGMT-PROC-FSM-XID-INFO

    grouping L2VPN-MGMT-PROC-FSM {
      description
        "L2VPN Process FSM Information";
      container failover-status {
        description "L2VPN failover status";
        uses L2VPN-FAILOVER-STATUS;
      }  // container failover-status

      container nsr-status {
        description
          "L2VPN NSR status and timestamp";
        uses L2VPN-NSR-ISSU-STATUS-INFO;
      }  // container nsr-status

      container issu-status {
        description
          "L2VPN ISSU Status and timestamp";
        uses L2VPN-NSR-ISSU-STATUS-INFO;
      }  // container issu-status

      leaf ha-role {
        type uint8;
        description "Current HA Role";
      }

      leaf issu-role {
        type uint8;
        description "Current ISSU Role";
      }

      leaf sync-flags {
        type uint32;
        description "Sync complete flags";
      }

      leaf sw-install-in-progress {
        type boolean;
        description
          "Is s/w install currently in progress?";
      }

      list xid-info {
        description "XID information";
        uses L2VPN-MGMT-PROC-FSM-XID-INFO;
      }  // list xid-info

      list report-card {
        description
          "L2VPN Collaborator report card";
        uses L2VPN-MGMT-PROC-FSM-REPORT-CARD;
      }  // list report-card
    }  // grouping L2VPN-MGMT-PROC-FSM

    grouping L2VPN-BRIDGE-SUMMARY {
      description "L2VPN BRIDGE SUMMARY";
      leaf number-groups {
        type uint32;
        description "Number of groups";
      }

      leaf number-vlan-switches {
        type uint32;
        description
          "Number of VLAN Switches";
      }

      leaf number-bridge-domains {
        type uint32;
        description
          "Number of bridge-domains";
      }

      leaf number-bridge-domains-up {
        type uint32;
        description
          "Number of bridge-domains up";
      }

      leaf number-bridge-domains-shut {
        type uint32;
        description
          "Number of bridge-domains admin disabled";
      }

      leaf number-default-bridge-doamins {
        type uint32;
        description
          "Number of default bridge-domains";
      }

      leaf number-pbb-edge {
        type uint32;
        description "Number of PBB Edge";
      }

      leaf number-pbb-core {
        type uint32;
        description "Number of PBB Core";
      }

      leaf number-p2mp {
        type uint32;
        description "Number of P2MPs";
      }

      leaf number-p2mp-up {
        type uint32;
        description
          "Number of P2MPs whose state is up";
      }

      leaf number-p2mp-down {
        type uint32;
        description
          "Number of P2MPs whose state is down";
      }

      leaf number-a-cs {
        type uint32;
        description
          "Number of attachment circuits";
      }

      leaf number-a-cs-up {
        type uint32;
        description
          "Number of attachment circuits whose state is up";
      }

      leaf number-a-cs-down {
        type uint32;
        description
          "Number of attachment circuits whose state is
         down";
      }

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

      leaf number-p-ws-up {
        type uint32;
        description
          "Number of pseudowires whose state is up";
      }

      leaf number-p-ws-down {
        type uint32;
        description
          "Number of pseudowires whose state is down";
      }

      leaf standby-pseudowires {
        type uint32;
        description
          "Number of pseudowires whose state is standby";
      }

      leaf num-vn-is {
        type uint32;
        description "Number of VNIs";
      }

      leaf num-vn-is-up {
        type uint32;
        description "Number of VNIs up";
      }

      leaf num-vn-is-down {
        type uint32;
        description "Number of VNIs down";
      }

      leaf num-vn-is-unresolved {
        type uint32;
        description
          "Number of VNIs unresolved";
      }

      leaf out-of-memory-state {
        type uint32;
        description
          "L2VPN Out of memory state";
      }

      leaf partially-programmed-bridges {
        type uint32;
        description
          "Number of partially programmed bridge-domains";
      }

      leaf partially-programmed-pseudowires {
        type uint32;
        description
          "Number of partially programmed pseudowires";
      }

      leaf partially-programmed-a-cs {
        type uint32;
        description
          "Number of partially programmed attachment
         circuits";
      }
    }  // grouping L2VPN-BRIDGE-SUMMARY

    grouping ICCP-SM-PORT-INFO {
      description
        "ICCP-based service multi-homing port information";
      leaf port-state {
        type Iccp-sm-port-state;
        description "Port state";
      }

      leaf port-fail-code {
        type uint8;
        description "Port fail code";
      }

      leaf fsm-state {
        type uint8;
        description "FSM state";
      }

      leaf vlan-state {
        type uint8;
        description "VLAN state";
      }

      leaf vlan-vector {
        type yang:hex-string;
        description
          "VLAN Vector. VLANList::=
         FivePackedVLANRoleVectorByte {
         ,FivePackedVLANRoleVectorByte}.
         FivePackedVLANRoleVectorByte =
         (((3*firstVLANRole + secondVLANRole)*3 +
         thirdVLANRole)*3 + fourthVLAN Role)*3 +
         fifthVLANRole. Role::= Primary | Secondary |
         NotConfigured. NotConfigured::= 0. Primary::= 1.
         Secondary::= 2";
      }

      leaf reversion-time {
        type uint32;
        description "Reversion Time";
      }

      leaf reversion-time-remaining {
        type uint32;
        description
          "Reversion Time Remaining";
      }
    }  // grouping ICCP-SM-PORT-INFO

    grouping ICCP-SM-PORT {
      description
        "ICCP-based service multi-homing port";
      container local-port {
        description "Local port info";
        uses ICCP-SM-PORT-INFO;
      }  // container local-port

      container remote-port {
        description "Remote port info";
        uses ICCP-SM-PORT-INFO;
      }  // container remote-port

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

      leaf mac-flush-tcn {
        type boolean;
        description
          "Is MAC flush through STP-TCN?";
      }
    }  // grouping ICCP-SM-PORT

    grouping ICCP-SM-GROUP {
      description
        "ICCP-based service multi-homing group";
      leaf group-id {
        type uint32;
        description "Group ID";
      }

      leaf local-node-id {
        type uint8;
        description "Local Node ID";
      }

      leaf remote-node-id {
        type uint8;
        description "Remote Node ID";
      }

      leaf state {
        type Iccp-sm-state;
        description "State";
      }

      leaf iccp-transport-up {
        type boolean;
        description "ICCP Transport Up";
      }

      leaf iccp-member-up {
        type boolean;
        description "ICCP Member Up";
      }

      list ports {
        description
          "List of ports in the group";
        uses ICCP-SM-PORT;
      }  // list ports
    }  // grouping ICCP-SM-GROUP

    grouping ICCP-SM-SUMMARY {
      description
        "ICCP-based service multi-homing group summary
       information";
      leaf groups {
        type uint32;
        description "Total Number of Groups";
      }

      leaf unresolved-groups {
        type uint32;
        description
          "Number of Unresolved Groups";
      }

      leaf provisioned-groups {
        type uint32;
        description
          "Number of Provisioned Groups";
      }

      leaf connecting-groups {
        type uint32;
        description
          "Number of Connecting Groups";
      }

      leaf connected-groups {
        type uint32;
        description
          "Number of Connected Groups";
      }

      leaf synchronizing-groups {
        type uint32;
        description
          "Number of Synchronizing Groups";
      }

      leaf synchronized-groups {
        type uint32;
        description
          "Number of Synchronized Groups";
      }

      leaf ports {
        type uint32;
        description "Total Number of Ports";
      }

      leaf operational-ports {
        type uint32;
        description
          "Number of Operational Ports";
      }

      leaf failed-ports {
        type uint32;
        description "Number of Failed Ports";
      }

      leaf unknown-ports {
        type uint32;
        description
          "Number of Unknown Ports";
      }

      leaf unconfigured-ports {
        type uint32;
        description
          "Number of Unconfigured Ports";
      }

      leaf unsynchronized-ports {
        type uint32;
        description
          "Number of Unsynchronized Ports";
      }

      leaf reverting-ports {
        type uint32;
        description
          "Number of Reverting Ports";
      }
    }  // grouping ICCP-SM-SUMMARY

    grouping L2VPN-MAIN-INTERFACE {
      description
        "L2VPN MAIN INTERFACE PORT";
      leaf main-interface-handle {
        type xr:Interface-name;
        description "Main Interface";
      }

      leaf is-protected {
        type boolean;
        description "IsProtected";
      }

      leaf interface-count {
        type uint32;
        description "Sub Interface Count";
      }

      leaf protect-type {
        type L2vpn-main-if-protect;
        description "Protect Type";
      }
    }  // grouping L2VPN-MAIN-INTERFACE

    grouping L2VPN-MAIN-INTERFACE-INSTANCE-BPORT {
      description
        "Bridge port of an instance";
      leaf bridge-port-xr {
        type xr:Interface-name;
        description "Bridge port ifhandle";
      }

      leaf instance-id {
        type uint32;
        description "Instance ID";
      }
    }  // grouping L2VPN-MAIN-INTERFACE-INSTANCE-BPORT

    grouping L2VPN-MAIN-INTERFACE-INSTANCE {
      description
        "L2VPN MAIN INTERFACE INSTANCE Entry";
      leaf configured-instance {
        type uint32;
        description "Configured Instance";
      }

      leaf flush-count {
        type uint32;
        description "Flush count ";
      }

      leaf interface-count {
        type uint32;
        description "Interface count";
      }

      leaf instance-flags {
        type uint32;
        description "Instance Flags";
      }

      leaf instance-id {
        type uint32;
        description "Instance ID";
      }

      leaf instance-state {
        type L2vpn-main-if-instance-state;
        description "Instance State";
      }
    }  // grouping L2VPN-MAIN-INTERFACE-INSTANCE

    grouping L2VPN-FXC-SUMMARY {
      description "L2VPN FXC SUMMARY";
      leaf number-fxc {
        type uint32;
        description
          "Number of flexible xconnect services";
      }

      leaf number-fxc-up {
        type uint32;
        description
          "Number of flexible xconnect services whose state
         is up";
      }

      leaf number-fxc-down {
        type uint32;
        description
          "Number of flexible xconnect services whose state
         is down";
      }
    }  // grouping L2VPN-FXC-SUMMARY

    grouping L2VPN-NLRI-LDP-SIG {
      description "L2VPN NLRI LDP SIG";
      leaf nlri-time-created {
        type uint32;
        description "NLRI creation time";
      }

      leaf local-address {
        type inet:ipv4-address;
        description "Local BGP Address";
      }

      leaf remote-address {
        type inet:ipv4-address;
        description "Remote BGP Address";
      }

      leaf remote-l2-router-id {
        type inet:ipv4-address;
        description "Remote L2VPN Router ID";
      }
    }  // grouping L2VPN-NLRI-LDP-SIG

    grouping L2VPN-VPLS-ID-V4ADDR {
      description "L2VPN VPLS ID V4ADDR";
      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPv4 Address";
      }

      leaf two-byte-index {
        type uint16;
        description "2 Byte Index";
      }
    }  // grouping L2VPN-VPLS-ID-V4ADDR

    grouping L2VPN-VPLS-ID-2BYTE-AS {
      description "L2VPN VPLS ID 2BYTE AS";
      leaf two-byte-as {
        type uint16;
        description "2 Byte AS Number";
      }

      leaf four-byte-index {
        type uint32;
        description "4 Byte Index";
      }
    }  // grouping L2VPN-VPLS-ID-2BYTE-AS

    grouping L2VPN-VPLS-ID-AUTO {
      description "L2VPN VPLS ID AUTO";
      leaf asn {
        type uint16;
        description "2 Byte AS Number";
      }

      leaf vpn-id {
        type uint32;
        description "VPN ID";
      }
    }  // grouping L2VPN-VPLS-ID-AUTO

    grouping L2VPN-VPLS-ID {
      description "L2VPN VPLS ID";
      container auto {
        when
          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
          description
            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
        }
        description "auto";
        uses L2VPN-VPLS-ID-AUTO;
      }  // container auto

      container two-byte-as {
        when
          "../vpls-id-type = 'l2vpn-ad-vpls-id-as'" {
          description
            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AS'";
        }
        description "two byte as";
        uses L2VPN-VPLS-ID-2BYTE-AS;
      }  // container two-byte-as

      container v4-addr {
        when
          "../vpls-id-type = 'l2vpn-ad-vpls-id-v4-addr'" {
          description
            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_V4ADDR'";
        }
        description "v4 addr";
        uses L2VPN-VPLS-ID-V4ADDR;
      }  // container v4-addr

      leaf vpls-id-type {
        type L2vpn-ad-vpls-id;
        description "VPLS ID TYPE";
      }
    }  // grouping L2VPN-VPLS-ID

    grouping L2VPN-DISCO-LDP-SIG {
      description "L2VPN DISCO LDP SIG";
      container local-vpls-id {
        description "Local VPLS-ID";
        uses L2VPN-VPLS-ID;
      }  // container local-vpls-id

      leaf local-l2-router-id {
        type inet:ipv4-address;
        description "Local L2VPN Router ID";
      }

      leaf number-remote-edges {
        type uint32;
        description "Number of remote Edges";
      }

      list remote-nlri {
        description "List of NLRIs";
        uses L2VPN-NLRI-LDP-SIG;
      }  // list remote-nlri
    }  // grouping L2VPN-DISCO-LDP-SIG

    grouping L2VPN-LABEL-BLOCK {
      description "L2VPN LABEL BLOCK";
      leaf label-time-created {
        type uint32;
        description "Creation time";
      }

      leaf label-base {
        type uint32;
        description "Label Base";
      }

      leaf block-offset {
        type uint32;
        description "Block offset";
      }

      leaf block-size {
        type uint32;
        description "Block size";
      }

      leaf local-edge-id {
        type uint32;
        description "Local edge ID";
      }

      leaf next-hop {
        type inet:ipv4-address;
        description " Peer id";
      }

      leaf label-error {
        type L2vpn-ad-lsd-err;
        description "Label Error";
      }

      list status-vector {
        description "Status Vector";
        leaf entry {
          type uint8;
          description "Status Vector";
        }
      }  // list status-vector
    }  // grouping L2VPN-LABEL-BLOCK

    grouping L2VPN-DISCO-EDGE {
      description "L2VPN DISCO EDGE";
      leaf edge-id {
        type uint32;
        description "Edge ids";
      }

      leaf label-count {
        type uint32;
        description "Number of label blocks";
      }

      list label-block {
        description "List of label blocks";
        uses L2VPN-LABEL-BLOCK;
      }  // list label-block
    }  // grouping L2VPN-DISCO-EDGE

    grouping L2VPN-DISCO-BGP-SIG {
      description "L2VPN DISCO BGP SIG";
      leaf number-edges {
        type uint32;
        description "Number of Edges";
      }

      leaf number-remote-edges {
        type uint32;
        description "Number of remote Edges";
      }

      list edge {
        description "List of edge ids";
        uses L2VPN-DISCO-EDGE;
      }  // list edge

      list redge {
        description "List of edge ids";
        uses L2VPN-DISCO-EDGE;
      }  // list redge
    }  // grouping L2VPN-DISCO-BGP-SIG

    grouping L2VPN-DISCO-SIG-INFO {
      description "L2VPN DISCO SIG INFO";
      container bgp-sig-info {
        when
          "../ad-signalling-method = 'l2vpn-ad-sig-method-bgp'" {
          description
            "../ADSignallingMethod =
           'L2VPN_AD_SIG_METHOD_BGP'";
        }
        description "bgp sig info";
        uses L2VPN-DISCO-BGP-SIG;
      }  // container bgp-sig-info

      container ldp-sig-info {
        when
          "../ad-signalling-method = 'l2vpn-ad-sig-method-ldp'" {
          description
            "../ADSignallingMethod =
           'L2VPN_AD_SIG_METHOD_LDP'";
        }
        description "ldp sig info";
        uses L2VPN-DISCO-LDP-SIG;
      }  // container ldp-sig-info

      leaf ad-signalling-method {
        type L2vpn-ad-sig-method;
        description "ADSignallingMethod";
      }
    }  // grouping L2VPN-DISCO-SIG-INFO

    grouping L2VPN-DISCO {
      description "L2VPN DISCO";
      container signalling-info {
        description
          "Info about signalling protocol";
        uses L2VPN-DISCO-SIG-INFO;
      }  // container signalling-info

      leaf mtu-mismatch-ignore {
        type boolean;
        description "Ignore MTU Mismatch";
      }

      leaf number-vpn {
        type uint32;
        description "Number of vpns";
      }

      leaf vpn-id {
        type uint32;
        description "VPN id";
      }

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

      leaf group-name-xr {
        type string;
        description "Group name";
      }

      leaf vpn-name-xr {
        type string;
        description "VPN instance name";
      }

      leaf is-service-connected {
        type boolean;
        description
          "Is the service connected";
      }
    }  // grouping L2VPN-DISCO

    grouping L2VPN-EVPN-REMOTE-SHG-INFO {
      description
        "L2VPN EVPN remote split horizon group labels";
      leaf next-hop {
        type inet:ipv6-address;
        description
          "Next-hop IP address (v6 format)";
      }

      leaf label {
        type uint32;
        description
          "Split horizon label associated with next-hop
         address";
      }
    }  // grouping L2VPN-EVPN-REMOTE-SHG-INFO
  }  // submodule Cisco-IOS-XR-l2vpn-oper-sub2