module Cisco-IOS-XR-l2vpn-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-l2vpn-oper";

    prefix 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-sub4 {
      revision-date "2020-05-05";
    }
    include Cisco-IOS-XR-l2vpn-oper-sub3 {
      revision-date "2020-05-05";
    }
    include Cisco-IOS-XR-l2vpn-oper-sub2 {
      revision-date "2020-05-05";
    }
    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 module contains a collection of YANG definitions
     for Cisco IOS-XR l2vpn package operational data.
     
     This module contains definitions
     for the following management objects:
       l2vpn-forwarding: Show L2VPN forwarding
       l2vpnv2: L2VPN operational data to support active and standby.
         L2VPN has been deprecated
       generic-interface-list-v2: Generic Interface List 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 L2tpv2-session-id-range {
      type uint32 {
        range "0..65535";
      }
      description "L2tpv2 session id range";
    }

    typedef Msti-range {
      type uint32 {
        range "0..1004";
      }
      description "Msti range";
    }

    typedef G8032-ring-instance-range {
      type uint32 {
        range "0..4294967295";
      }
      description
        "G8032 ring instance range";
    }

    typedef Main-interface-id-range {
      type uint32 {
        range "0..4294967295";
      }
      description "Main interface id range";
    }

    typedef L2vpn-service {
      type enumeration {
        enum "vpws" {
          value 0;
          description "VPWS service";
        }
        enum "vpls" {
          value 1;
          description "VPLS service";
        }
      }
      description "L2vpn service";
    }

    typedef Bridge-id-range {
      type uint32 {
        range "0..262144";
      }
      description "Bridge id range";
    }

    typedef Lsm-id-range {
      type uint32 {
        range "1..1048574";
      }
      description "Lsm id range";
    }

    typedef P2mp-id-range {
      type uint32 {
        range "0..4294967295";
      }
      description "P2mp id range";
    }

    typedef Tunnel-id-range {
      type uint32 {
        range "0..65535";
      }
      description "Tunnel id range";
    }

    typedef L2tpv3-session-id-range {
      type uint32 {
        range "0..4294967295";
      }
      description "L2tpv3 session id range";
    }

    typedef Preferred-path-option {
      type enumeration {
        enum "te-tunnel" {
          value 2;
          description "TE Tunnel";
        }
        enum "ip-tunnel" {
          value 3;
          description "IP Tunnel";
        }
        enum "tp-tunnel" {
          value 4;
          description "TP Tunnel";
        }
        enum "sr-te-policy" {
          value 5;
          description "SR TE Policy";
        }
        enum "mldp-tunnel" {
          value 6;
          description "mLDP Tunnel";
        }
        enum "mte-tunnel" {
          value 7;
          description "mTE Tunnel";
        }
        enum "named-te-tunnel" {
          value 8;
          description "Named TE Tunnel";
        }
      }
      description "Preferred path option";
    }

    typedef Evpn-main-interface {
      type enumeration {
        enum "evpn-main-interface-ac" {
          value 1;
          description
            "EVPN main interface type AC";
        }
        enum "evpn-main-interface-nve" {
          value 2;
          description
            "EVPN main interface type NVE";
        }
        enum "evpn-main-interface-ac-vfi" {
          value 3;
          description
            "EVPN main interface type AC VFI";
        }
        enum "evpn-main-interface-ac-pw" {
          value 4;
          description
            "EVPN main interface type AC PW";
        }
      }
      description "Evpn main interface";
    }

    typedef L2fib-next-hop-key {
      type enumeration {
        enum "nexthop-ipv4" {
          value 1;
          description "IPv4 Nexthop type";
        }
        enum "nexthop-mpls-internal-label" {
          value 2;
          description
            "MPLS Internal-Label Nexthop type";
        }
        enum "nexthop-ipv6" {
          value 3;
          description "IPv6 Nexthop type";
        }
        enum "nexthop-vx-lan-internal-label" {
          value 4;
          description
            "Vxlan Internal-Label Nexthop type";
        }
        enum "nexthop-sr-te-bsid" {
          value 5;
          description
            "SR-TE BindingSID Nexthop type";
        }
        enum "nexthop-te-tunnel" {
          value 6;
          description
            "TE Tunnel Nexthop type";
        }
        enum "nexthop-lsm-id" {
          value 7;
          description "LSM ID Nexthop type";
        }
        enum "nexthop-iid" {
          value 8;
          description
            "Internal-ID Nexthop type";
        }
      }
      description "L2fib next hop key";
    }

    typedef Pw-group-id-range {
      type uint32 {
        range "0..4294967295";
      }
      description "Pw group id range";
    }

    typedef L2vpnp2mp-ptree {
      type enumeration {
        enum "rsvp-te" {
          value 1;
          description "RSVPTE Type";
        }
        enum "mldp" {
          value 2;
          description "MLDP Type";
        }
      }
      description "L2vpnp2mp ptree";
    }

    typedef L2fib-evpn-moi {
      type enumeration {
        enum "ipv4-label" {
          value 0;
          description "IPv4 label type";
        }
        enum "sr-te-interface" {
          value 1;
          description "SR-TE interface type";
        }
        enum "sr-te-bsid" {
          value 2;
          description
            "SR-TE Binding Label (BSID) type";
        }
        enum "sr-te-bsi-dv6" {
          value 3;
          description "SR-TE BSIDv6 type";
        }
      }
      description "L2fib evpn moi";
    }

    typedef Rib-iid-range {
      type uint32 {
        range "0..4294967295";
      }
      description "Rib iid range";
    }

    typedef L2vpnpw {
      type enumeration {
        enum "manual" {
          value 1;
          description "Manual pseudowire";
        }
        enum "vpls-autodiscovered" {
          value 2;
          description
            "VPLS autodiscovered pseudowire";
        }
        enum "vpws-autodiscovered" {
          value 3;
          description
            "VPWS autodiscovered pseudowire";
        }
        enum "vpls-autodiscovered-ldp" {
          value 4;
          description
            "VPLS autodiscovered pseudowire with LDP
           signaling";
        }
      }
      description "L2vpnpw";
    }

    container l2vpn-forwarding {
      config false;
      description "Show L2VPN forwarding";
      container nodes {
        description
          "Per node L2VPN forwarding Operational data";
        list node {
          key "node-id";
          description
            "The L2VPN forwarding Operational data for a
           particular node";
          container l2fibx-con-locals {
            description
              "The L2VPN forwarding Local LC XConnect Detail
             Table";
            list l2fibx-con-local {
              description "Specify Sub Ifh";
              leaf interface-name {
                type xr:Interface-name;
                description "Interface Name";
              }

              leaf vsp-vlan-id {
                type uint32 {
                  range "0..4094";
                }
                description
                  "VLAN-Switched Port VLAN ID";
              }

              container segment1 {
                description
                  "Segment1 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  container pbb-union {
                    description
                      "Union of Edge and Core";
                    container edge {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-edge'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_EDGE'";
                      }
                      description "edge";
                      leaf mac-configured {
                        type boolean;
                        description
                          "Configured MAC";
                      }

                      leaf mac {
                        type yang:mac-address;
                        description
                          "unknown unicast bmac";
                      }
                    }  // container edge

                    container core {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-core'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_CORE'";
                      }
                      description "core";
                      leaf vlan-id {
                        type uint32;
                        description
                          "vlan id";
                      }
                    }  // container core

                    leaf pbb-type {
                      type Mgmt-l2fib-bridge;
                      description "PbbType";
                    }
                  }  // container pbb-union

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf core-pbb-evpn-enabled {
                    type boolean;
                    description
                      "Core PBB-EVPN enabled";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf srcip {
                    type inet:ipv4-address;
                    description
                      "VNI Src IPv4 Address";
                  }

                  leaf mcastip {
                    type inet:ipv4-address;
                    description
                      "VNI Mcast IP Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf encap {
                    type uint32;
                    description
                      "Encap type of VNI";
                  }

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

                  leaf source-vtep-if {
                    type xr:Interface-name;
                    description
                      "Source IF Handle";
                  }

                  leaf any-cast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast VTEP IP";
                  }

                  leaf anycast-mcast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast Multicast IP";
                  }

                  leaf ingress-replication {
                    type boolean;
                    description
                      "Ingress Replication supported on VNI";
                  }

                  leaf vx-lan-mode {
                    type uint32;
                    description "Vxlan mode";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evi {
                    type uint32;
                    description "EVPN ID";
                  }

                  leaf forward-class {
                    type uint8;
                    description
                      "Forward Class";
                  }
                }  // container evpn

                container monitor-session {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description
                    "monitor session";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf session-name {
                    type string;
                    description
                      "Monitor Session Name";
                  }

                  leaf hardware-information {
                    type yang:hex-string;
                    description
                      "hardware Information of Monitor Session";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }
                }  // container monitor-session

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn' and ../data-type != 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN' and
../DataType != 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment1

              container segment2 {
                description
                  "Segment2 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container bp {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-bridge-port'" {
                    description
                      "../DataType =
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT'";
                  }
                  description "bp";
                  container oper {
                    description
                      "Operational information";
                    container operational-information {
                      description
                        "L2 operational information";
                      leaf mtu {
                        type uint32;
                        description "MTU";
                      }

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

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

                      leaf number-of-macs {
                        type uint32;
                        description
                          "numberOfMacs";
                      }

                      leaf admin-disabled {
                        type boolean;
                        description
                          "Is administratively disabled";
                      }

                      leaf flooding-disabled {
                        type boolean;
                        description
                          "Is flooding disabled";
                      }

                      leaf flood-unknown-unicast-enabled {
                        type boolean;
                        description
                          "Is flooding unknown unicast disabled";
                      }

                      leaf mac-limit-action {
                        type Mgmt-l2fib-mac-limit-action;
                        description
                          "MAC limit action";
                      }

                      leaf mac-limit-threshold {
                        type uint32;
                        units "percentage";
                        description
                          "MAC limit percentage recovery threshold";
                      }

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

                      leaf mac-port-down-flush-disabled {
                        type boolean;
                        description
                          "Is MAC port down flush disabled";
                      }

                      leaf mac-limit-notification-type {
                        type Mgmt-l2fib-mac-limit-notify;
                        description
                          "MAC limit notification";
                      }

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

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

                      leaf mac-secure-action {
                        type Mgmt-l2fib-mac-sec-action;
                        description
                          "MAC secure action";
                      }

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

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

                      leaf mac-aging-type {
                        type Mgmt-l2fib-mac-aging;
                        description
                          "MAC aging type";
                      }

                      leaf l2mc-src-traffic-enabled {
                        type uint32;
                        description
                          "L2MC Source Traffic Enabled";
                      }

                      leaf storm-control-unicast-enabled {
                        type boolean;
                        description
                          "Is unicast storm control enabled";
                      }

                      leaf storm-control-broadcast-enabled {
                        type boolean;
                        description
                          "Is broadcast storm control enabled";
                      }

                      leaf storm-control-multicast-enabled {
                        type boolean;
                        description
                          "Is multicast storm control enabled";
                      }

                      leaf storm-control-unicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control unicast rate unit";
                      }

                      leaf storm-control-broadcast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control broadcast rate unit";
                      }

                      leaf storm-control-multicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control multicast rate unit";
                      }

                      leaf dhcp-enabled {
                        type boolean;
                        description
                          "Is DHCP snooping enabled";
                      }

                      leaf dhcp-trusted {
                        type boolean;
                        description
                          "Is DHCP trusted";
                      }

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

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

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

                      leaf is-dai-addr-validation-destination-mac-enabled {
                        type boolean;
                        description
                          "Is DAI Destination MAC Validation enabled";
                      }

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

                      leaf is-ipsg-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-vpls-flood-optimization-enabled {
                        type boolean;
                        description
                          "Is MMRP  Flood Optimization Enabled";
                      }

                      leaf igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping enabled";
                      }

                      leaf igmp-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping profile enabled";
                      }

                      leaf igmp-flood-forward-enabled {
                        type boolean;
                        description
                          "Is IGMP flood forwarding enabled";
                      }

                      leaf igmp-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf igmp-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf mld-snoop-enabled {
                        type boolean;
                        description
                          "Is MLD snooping enabled";
                      }

                      leaf mld-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is MLD snooping profile enabled";
                      }

                      leaf mld-flood-forward-enabled {
                        type boolean;
                        description
                          "Is MLD flood forwarding enabled";
                      }

                      leaf mld-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf mld-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf stp-participating {
                        type boolean;
                        description
                          "Is Spanning Tree Protocol participating";
                      }

                      leaf bvi-configured {
                        type boolean;
                        description
                          "Is BVI Interface configured";
                      }

                      leaf is-bvi-up {
                        type boolean;
                        description
                          "Is BVI state UP";
                      }

                      leaf is-vni-enabled {
                        type boolean;
                        description
                          "Is VNI enabled";
                      }

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

                      leaf unknown-unicast-flooding-disabled {
                        type boolean;
                        description
                          "Unknown Unicast Flooding is disabled";
                      }

                      leaf is-pbbevpn-enabled {
                        type boolean;
                        description
                          "Is PBBEVPN enabled";
                      }

                      leaf is-swmac-learning {
                        type boolean;
                        description
                          "Is SW MAC learning enabled";
                      }

                      leaf is-evpn-flow-label {
                        type boolean;
                        description
                          "Is EVPN Flow Label enabled";
                      }

                      leaf is-evpn-cw-disable {
                        type boolean;
                        description
                          "Is EVPN CW disabled";
                      }

                      leaf msti {
                        type uint32;
                        description
                          "Multi-spanning tree instance";
                      }

                      leaf is-p2mp-pw-enabled {
                        type boolean;
                        description
                          "Is P2MP PW enabled";
                      }

                      leaf is-igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP Snooping admin enabled";
                      }

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

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

                      leaf is-ves {
                        type boolean;
                        description
                          "Is Virtual Ethernet Segement feature enabled";
                      }

                      list feature {
                        description
                          "Feature information";
                        container dhcp {
                          when
                            "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                          }
                          description "dhcp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container dhcp

                        container igmp {
                          when
                            "../feature-type = 'l2fib-feature-igmp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                          }
                          description "igmp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container igmp

                        container mld {
                          when
                            "../feature-type = 'l2fib-feature-mld-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                          }
                          description "mld";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container mld

                        leaf feature-type {
                          type L2fib-feature;
                          description
                            "feature type";
                        }
                      }  // list feature
                    }  // container operational-information

                    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 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 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";
                    }
                  }  // container oper

                  container p2mp {
                    description
                      "BP P2MP PW Information";
                    leaf ptree-type {
                      type L2vpn-ptree;
                      description
                        "P2MP ptree type";
                    }

                    leaf lsm-id {
                      type uint32;
                      description
                        "MLDP LSM id";
                    }

                    leaf tunnel-id {
                      type uint16;
                      description
                        "TE Tunnel Id";
                    }

                    leaf p2mp-id {
                      type uint16;
                      description
                        "TE P2MP Id";
                    }

                    leaf extended-tunnel-id {
                      type inet:ipv4-address;
                      description
                        "TE Extended Tunnel Id";
                    }

                    leaf ptree-owner-lmrib {
                      type boolean;
                      description
                        "PTree Owner LMRIB";
                    }
                  }  // container p2mp

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

                  leaf shg-id {
                    type uint32;
                    description
                      "Split horizon group ID";
                  }

                  leaf msti-pointer {
                    type uint32;
                    description
                      "MSTI Pointer";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }

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

                  leaf learn-key {
                    type uint8;
                    description "Learn Key";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evpn-shg-local-label {
                    type uint32;
                    description
                      "EVPN split horizon group local label";
                  }

                  list evpn-shg-remote-info {
                    description
                      "EVPN split horizon group remote info";
                    container remote-split-horizon-group-label {
                      description
                        "Remote split horizon group label";
                      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";
                      }
                    }  // container remote-split-horizon-group-label
                  }  // list evpn-shg-remote-info
                }  // container bp

                container fxs {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "fxs";
                  leaf fxs-id {
                    type uint32;
                    description "FXS ID";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }
                }  // container fxs

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-bridge-port' and ../data-type != 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType !=
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment2

              leaf xcon-name {
                type string {
                  length "0..72";
                }
                description "Xconnect name";
              }

              leaf bound {
                type boolean;
                description "Bound";
              }

              leaf switching-type {
                type Mgmt-l2fib-switching;
                description "SW Type";
              }
            }  // list l2fibx-con-local
          }  // container l2fibx-con-locals

          container l2fib-mroute-summaries {
            description
              "Mroute Summary Table";
            list l2fib-mroute-summary {
              description
                "Multicast Summary Information";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Group Name";
              }

              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf bridge-domain-name {
                type string {
                  length "0..66";
                }
                description "Bridge Name";
              }

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

              leaf multicast-update {
                type uint32;
                description
                  "Multicast Updates";
              }

              leaf multicast-update-dropped {
                type uint32;
                description
                  "Multicast Updates";
              }

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

              leaf number-of-routes-with-ole-offload {
                type uint32;
                description
                  "Number of Routes with OleOffload";
              }

              leaf number-of-mroute-add {
                type uint32;
                description
                  "Number of Mroutes Added";
              }

              leaf number-mroute-deleted {
                type uint32;
                description
                  "Number of Mroutes Deleted";
              }

              leaf number-mroutes-deleted-all {
                type uint32;
                description
                  "Number of Mroutes All Deleted";
              }

              leaf number-mroute-delete-drop {
                type uint32;
                description
                  "Number of Mroutes Delete droped";
              }

              leaf number-mroute-all-delete-drop {
                type uint32;
                description
                  "Number of Mroutes All Delete droped";
              }

              leaf number-xid-add {
                type uint32;
                description
                  "Number of XID Added";
              }

              leaf number-xid-deleted {
                type uint32;
                description
                  "Number of XID Deleted";
              }

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

              leaf stale-deleted {
                type uint32;
                description "Stale Deleted";
              }

              leaf stale-xid-deleted {
                type uint32;
                description
                  "Stale XID Deleted";
              }

              list message {
                description
                  "Global Message Information";
                leaf message-count {
                  type uint32;
                  description
                    "number of message";
                }

                leaf time {
                  type string;
                  description "Time string";
                }

                leaf information1 {
                  type uint32;
                  description "Extra info 1";
                }

                leaf information2 {
                  type uint32;
                  description "Extra info 2";
                }

                leaf description {
                  type string;
                  description
                    "Description of the message";
                }
              }  // list message
            }  // list l2fib-mroute-summary
          }  // container l2fib-mroute-summaries

          container l2fib-message-summary {
            description
              "L2FIB Message Summary information";
            container event-history {
              description
                "Event history buffer";
              leaf event-neighbor-entry {
                type uint16;
                description
                  "number of item in the array";
              }

              list extra-information1 {
                max-elements 256;
                description
                  "extra information1";
                leaf entry {
                  type uint32;
                  description "entry";
                }
              }  // list extra-information1

              list extra-information2 {
                max-elements 256;
                description
                  "extra information2";
                leaf entry {
                  type uint32;
                  description "entry";
                }
              }  // list extra-information2

              list event-entry {
                max-elements 256;
                description "event entry";
                leaf event-time {
                  type string {
                    length "0..32";
                  }
                  description
                    "The real timestamp of the event";
                }

                leaf event-type {
                  type uint8;
                  description "Event type";
                }

                leaf event-many {
                  type boolean;
                  description
                    "Multiple event instance flag";
                }

                leaf event-sticky {
                  type boolean;
                  description
                    "Unwrittable flag";
                }

                leaf event-flags {
                  type uint32;
                  description
                    "base flag object";
                }
              }  // list event-entry
            }  // container event-history

            container round-trip-delay {
              description "Round-Trip delay";
              container bdxc-rtd {
                description "bdxc rtd";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // container bdxc-rtd

              container aging-rtd {
                description "aging rtd";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // container aging-rtd

              container punt-rtd {
                description "punt rtd";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // container punt-rtd

              container lock-rtd {
                description "lock rtd";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // container lock-rtd

              container platform-init-rtd {
                description
                  "platform init rtd";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // container platform-init-rtd

              leaf rtd-max-obj-type {
                type uint32;
                description
                  "RTD MAX OBJTYPE";
              }

              list create {
                max-elements 45;
                description "create";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list create

              list modify {
                max-elements 45;
                description "modify";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list modify

              list delete {
                max-elements 45;
                description "delete";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list delete

              list bind {
                max-elements 45;
                description "bind";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list bind

              list unbind {
                max-elements 45;
                description "unbind";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list unbind

              list mac-flush {
                max-elements 45;
                description "mac flush";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list mac-flush

              list pirtd {
                max-elements 45;
                description "pirtd";
                leaf number-pd-update {
                  type uint32;
                  description
                    "The number of time PD is called";
                }

                leaf number-pd-update-zero {
                  type uint32;
                  description
                    "The number of time PD is called in 0 time";
                }

                leaf minimum-round-trip-delay {
                  type uint64;
                  description
                    "The minimum round trip delay";
                }

                leaf maximum-round-trip-delay {
                  type uint64;
                  description
                    "The maximum round trip delay";
                }

                leaf average-round-trip-delay {
                  type uint64;
                  description
                    "The average round trip delay";
                }
              }  // list pirtd
            }  // container round-trip-delay

            list message {
              description "message";
              leaf message-count {
                type uint32;
                description
                  "number of message";
              }

              leaf time {
                type string;
                description "Time string";
              }

              leaf information1 {
                type uint32;
                description "Extra info 1";
              }

              leaf information2 {
                type uint32;
                description "Extra info 2";
              }

              leaf description {
                type string;
                description
                  "Description of the message";
              }
            }  // list message
          }  // container l2fib-message-summary

          container l2fib-mroutes {
            description
              "multicast information";
            list l2fib-mroute {
              description
                "Bridge Domain Multicast Information";
              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

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

              leaf group {
                type inet:ipv4-address-no-zone;
                description
                  "Group IP Address";
              }

              container source-prefix {
                description "Source Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container source-prefix

              container destination-prefix {
                description
                  "Destination Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container destination-prefix

              container forward-stats {
                description
                  "Forwarding Statistics";
                container forward-stat {
                  description "fwd stats";
                  container mulicast {
                    when
                      "../data-type = 'mgmt-l2fib-stats-type-mcast'" {
                      description
                        "../DataType = 'MGMT_L2FIB_STATS_TYPE_MCAST'";
                    }
                    description "mulicast";
                    container multicast-forward-stat {
                      description
                        "forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-forward-stat

                    container received-stat {
                      description
                        "received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container received-stat

                    container punt {
                      description
                        "punted stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container punt

                    container drop {
                      description
                        "dropped stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container drop

                    container multicast-core-forward-stat {
                      description
                        "core forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-core-forward-stat

                    container core-received-stat {
                      description
                        "core received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container core-received-stat
                  }  // container mulicast

                  leaf data-type {
                    type Mgmt-l2fib-stats-data;
                    description "DataType";
                  }
                }  // container forward-stat
              }  // container forward-stats

              container irb-info {
                description
                  "IRB Information";
                leaf mxid-ac-interface-handle {
                  type xr:Interface-name;
                  description
                    "Master XID AC If handle";
                }

                leaf mxid-pw-id {
                  type uint32;
                  description
                    "Master XID PW ID";
                }

                leaf mxid-next-hop-address {
                  type inet:ipv4-address;
                  description
                    "Master XID NHOP IP Address";
                }

                leaf irb-plat-data-len {
                  type uint16;
                  units "byte";
                  description
                    "Platform data bytes";
                }

                list irb-plat-data {
                  max-elements 16;
                  description
                    "IRB platform data";
                  leaf entry {
                    type uint32;
                    description
                      "IRB platform data";
                  }
                }  // list irb-plat-data
              }  // container irb-info

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

              leaf xid-count {
                type uint16;
                description "Count of XIDs";
              }

              leaf platform-data-length {
                type uint8;
                description
                  "The mcast platform data len";
              }

              leaf platform-data {
                type yang:hex-string;
                description
                  "The mcast platform data";
              }

              leaf hardware-information {
                type yang:hex-string;
                description
                  "Platform Hardware info";
              }

              leaf bridge-domain-name {
                type string {
                  length "0..66";
                }
                description "Bridge Name";
              }
            }  // list l2fib-mroute
          }  // container l2fib-mroutes

          container pbb-bmac-sa {
            description
              "PBB Backbone Source MAC information";
            leaf configured {
              type boolean;
              description
                "BMAC SA configured";
            }

            leaf mac {
              type yang:mac-address;
              description
                "Backbone Source Mac";
            }

            leaf chassis-mac {
              type yang:mac-address;
              description "Chassis Mac";
            }
          }  // container pbb-bmac-sa

          container l2fib-mac-learning {
            description
              "The L2VPN forwarding Mac Learning Data";
            container l2fib-mac-learning-macs {
              description
                "The L2VPN forwarding All Mac Learning Table";
              list l2fib-mac-learning-mac {
                description
                  "The attributes for a particular learned Mac
                 Route";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                leaf address {
                  type inet:ip-address-no-zone;
                  description "IP Address";
                }

                leaf bdid {
                  type Bridge-id-range;
                  description "BD ID";
                }

                leaf mac-address {
                  type yang:mac-address;
                  description "MAC Address";
                }

                container addr {
                  description "IP Address";
                  leaf addr-type {
                    type L2fib-ip-addr;
                    description "addr type";
                  }

                  leaf ip {
                    type inet:ipv6-address;
                    description "ip";
                  }
                }  // container addr

                container nhaddr {
                  description "IP Address";
                  leaf addr-type {
                    type L2fib-ip-addr;
                    description "addr type";
                  }

                  leaf ip {
                    type inet:ipv6-address;
                    description "ip";
                  }
                }  // container nhaddr

                leaf element-type {
                  type uint8;
                  description "Element Type";
                }

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

                leaf topology-id {
                  type uint32;
                  description "Topology ID";
                }

                leaf mac-address-xr {
                  type yang:mac-address;
                  description "MAC Address";
                }

                leaf interface-handle {
                  type uint32;
                  description
                    "Interface Handle";
                }

                leaf xcid {
                  type uint32;
                  description
                    "Cross-connect Identifier";
                }

                leaf generation {
                  type uint8;
                  description
                    "HW MAC generation";
                }
              }  // list l2fib-mac-learning-mac
            }  // container l2fib-mac-learning-macs

            container l2fib-mac-learning-mac-ipv4s {
              description
                "The L2VPN forwarding Mac IPV4 Learning Table";
              list l2fib-mac-learning-mac-ipv4 {
                description
                  "The attributes for a particular learned IPV4
                 Mac Route";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                leaf address {
                  type inet:ip-address-no-zone;
                  description "IP Address";
                }

                leaf bdid {
                  type Bridge-id-range;
                  description "BD ID";
                }

                leaf mac-address {
                  type yang:mac-address;
                  description "MAC Address";
                }

                container addr {
                  description "IP Address";
                  leaf addr-type {
                    type L2fib-ip-addr;
                    description "addr type";
                  }

                  leaf ip {
                    type inet:ipv6-address;
                    description "ip";
                  }
                }  // container addr

                container nhaddr {
                  description "IP Address";
                  leaf addr-type {
                    type L2fib-ip-addr;
                    description "addr type";
                  }

                  leaf ip {
                    type inet:ipv6-address;
                    description "ip";
                  }
                }  // container nhaddr

                leaf element-type {
                  type uint8;
                  description "Element Type";
                }

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

                leaf topology-id {
                  type uint32;
                  description "Topology ID";
                }

                leaf mac-address-xr {
                  type yang:mac-address;
                  description "MAC Address";
                }

                leaf interface-handle {
                  type uint32;
                  description
                    "Interface Handle";
                }

                leaf xcid {
                  type uint32;
                  description
                    "Cross-connect Identifier";
                }

                leaf generation {
                  type uint8;
                  description
                    "HW MAC generation";
                }
              }  // list l2fib-mac-learning-mac-ipv4
            }  // container l2fib-mac-learning-mac-ipv4s

            container l2fib-mac-learning-mac-ipv6s {
              description
                "The L2VPN forwarding Mac IPV6 Learning Table";
              list l2fib-mac-learning-mac-ipv6 {
                description
                  "The attributes for a particular learned IPV6
                 Mac Route";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                leaf address {
                  type inet:ip-address-no-zone;
                  description "IP Address";
                }

                leaf bdid {
                  type Bridge-id-range;
                  description "BD ID";
                }

                leaf mac-address {
                  type yang:mac-address;
                  description "MAC Address";
                }

                container addr {
                  description "IP Address";
                  leaf addr-type {
                    type L2fib-ip-addr;
                    description "addr type";
                  }

                  leaf ip {
                    type inet:ipv6-address;
                    description "ip";
                  }
                }  // container addr

                container nhaddr {
                  description "IP Address";
                  leaf addr-type {
                    type L2fib-ip-addr;
                    description "addr type";
                  }

                  leaf ip {
                    type inet:ipv6-address;
                    description "ip";
                  }
                }  // container nhaddr

                leaf element-type {
                  type uint8;
                  description "Element Type";
                }

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

                leaf topology-id {
                  type uint32;
                  description "Topology ID";
                }

                leaf mac-address-xr {
                  type yang:mac-address;
                  description "MAC Address";
                }

                leaf interface-handle {
                  type uint32;
                  description
                    "Interface Handle";
                }

                leaf xcid {
                  type uint32;
                  description
                    "Cross-connect Identifier";
                }

                leaf generation {
                  type uint8;
                  description
                    "HW MAC generation";
                }
              }  // list l2fib-mac-learning-mac-ipv6
            }  // container l2fib-mac-learning-mac-ipv6s
          }  // container l2fib-mac-learning

          container l2fib-p2mp {
            description "p2mp information";
            container ptrees {
              description
                "ptree information";
              list ptree {
                description
                  "P2MP PTree Information";
                leaf ptree-type {
                  type L2vpnp2mp-ptree;
                  description "PTree Type";
                }

                leaf lsm-id {
                  type Lsm-id-range;
                  description "LSM Id";
                }

                leaf tunnel-id {
                  type Tunnel-id-range;
                  description "Tunnel Id";
                }

                leaf p2mp-id {
                  type P2mp-id-range;
                  description "P2MP Id";
                }

                leaf extended-tunnel-id {
                  type inet:ipv4-address-no-zone;
                  description
                    "Extended Tunnel Id";
                }

                leaf lsm-id-xr {
                  type uint32;
                  description "MLDP Lsm Id";
                }

                leaf tunnel-id-xr {
                  type uint32;
                  description
                    "RSVPTE Tunnel Id";
                }

                leaf p2mp-id-xr {
                  type uint32;
                  description
                    "RSVPTE P2MP Id";
                }

                leaf extended-tunnel-id-xr {
                  type inet:ipv4-address;
                  description
                    "RSVPTE Ext Tunnel Id";
                }
              }  // list ptree
            }  // container ptrees
          }  // container l2fib-p2mp

          container l2fibmac-hardware-ingresses {
            description
              "Bridge Hardware Ingress information";
            list l2fibmac-hardware-ingress {
              description
                "MAC Hardware Ingress information";
              leaf address {
                type yang:mac-address;
                description
                  "Static MAC address";
              }

              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Group Name";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..27";
                }
                description
                  "Bridge Domain Name";
              }

              container segment {
                description "Segment";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  leaf interface-name {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  leaf vsp-vlan {
                    type uint16;
                    description
                      "VLAN-Switched Port VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf parent-if {
                    type xr:Interface-name;
                    description
                      "Parent NVE Interface";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }
                }  // container evpn

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "pw";
                  leaf pw-id {
                    type uint64;
                    description
                      "Pseudowire ID";
                  }

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

                  leaf pseudo-wire-id-type {
                    type L2fib-pw-id;
                    description
                      "Pseudowire ID type";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment

              container evpn-ctx {
                description "Evpn Context";
                container mcast-ole {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-moi'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_MOI'";
                  }
                  description "mcast ole";
                  leaf tunnel-endpoint-id {
                    type uint32;
                    description
                      "Tunnel Endpoint ID";
                  }

                  leaf mcast-encapsulation {
                    type uint32;
                    description
                      "Inclusive mcast transport encap";
                  }

                  leaf moi-type {
                    type L2vpn-evpn-moi;
                    description
                      "MOI Next Hop type";
                  }

                  leaf next-hop-ipv6-addr {
                    type inet:ipv6-address;
                    description
                      "Next Hop IPv6 address";
                  }

                  leaf mcast-label {
                    type uint32;
                    description
                      "Inclusive mcast label";
                  }

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

                  leaf sr-te-bsid {
                    type uint32;
                    description
                      "SR-TE Binding Label (BSID)";
                  }

                  leaf srv6-te-bsid {
                    type inet:ipv6-address;
                    description
                      "SRv6-TE Binding SID";
                  }
                }  // container mcast-ole

                leaf data-type {
                  type Mgmt-l2fib-bridge-mac-evpn-ctx;
                  description "DataType";
                }

                leaf esi-id {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-esi-id'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_ESI_ID'";
                  }
                  type uint16;
                  description "EsiID";
                }

                leaf local-label {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-local-label'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_LOCAL_LABEL'";
                  }
                  type uint32;
                  description "LocalLabel";
                }

                leaf bp-ifh {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-bp-ifh'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_BP_IFH'";
                  }
                  type xr:Interface-name;
                  description "BP IFH";
                }

                leaf internal-id {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-internal-id'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_INTERNAL_ID'";
                  }
                  type uint32;
                  description "InternalID";
                }
              }  // container evpn-ctx

              container next-hop {
                description "Next Hop";
                leaf type {
                  type L2fib-nhop;
                  description "Nexthop Type";
                }

                leaf next-hop-address {
                  type inet:ipv4-address;
                  description "NHOP Address";
                }

                leaf next-hop-address-v6 {
                  type inet:ipv6-address;
                  description
                    "NHOP Address V6";
                }

                leaf next-hop-te-interface-name {
                  type xr:Interface-name;
                  description
                    "NHOP (SR-)TE Interface";
                }

                leaf next-hop-lsm-id {
                  type uint32;
                  description "NHOP LSM ID";
                }

                leaf next-hop-sr-te-bsid {
                  type uint32;
                  description
                    "NHOP SR-TE Binding Label (BSID)";
                }

                leaf next-hop-internal-label {
                  type uint32;
                  description
                    "NHOP Internal Label";
                }

                leaf next-hop-internal-id {
                  type uint32;
                  description
                    "NHOP Internal ID";
                }

                leaf pin-down-interface-name {
                  type xr:Interface-name;
                  description
                    "Pin-down Interface Name";
                }

                leaf ecd-platform-data-valid {
                  type boolean;
                  description
                    "Is Platform ECD Data Valid";
                }

                leaf ecd-platform-data-length {
                  type uint32;
                  description
                    "Platform ECD Data Length";
                }

                leaf children-count {
                  type uint32;
                  description
                    "Children Count";
                }

                leaf children-evpn-ole-count {
                  type uint32;
                  description
                    "Children EVPN OLE Count";
                }

                leaf children-mac-count {
                  type uint32;
                  description
                    "Children MAC Count";
                }

                leaf children-pwhe-mp-count {
                  type uint32;
                  description
                    "Children PW-HE MainPort Count";
                }

                leaf children-ac-backup-count {
                  type uint32;
                  description
                    "Children AC-BACKUP Count";
                }

                leaf children-pw-ipv4-interface-list-count {
                  type uint32;
                  description
                    "Children PW IP-IFL Count";
                }

                leaf children-pw-te-tunnel-interface-list-count {
                  type uint32;
                  description
                    "Children PW IFH-IFL Count";
                }
              }  // container next-hop

              leaf platform-is-hw-learn {
                type uint8;
                description
                  "Platform is HW Learn";
              }

              leaf node-id {
                type xr:Node-id;
                description "Nodeid list";
              }

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

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

              leaf bmac-configured {
                type boolean;
                description
                  "Flag: Configured BMAC";
              }

              leaf vni-l3-flag {
                type boolean;
                description "Flag: L3 Vxlan";
              }

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

              leaf l3-encapsulationvlan-id {
                type uint16;
                description
                  "L3 encapsulation Vlan ID";
              }

              leaf next-hop-valid {
                type boolean;
                description
                  "IS Next Hop Valid";
              }

              leaf peer-vtep-ip {
                type inet:ipv4-address;
                description
                  "Peer VTEP IP for this MAC Address";
              }

              leaf flag-extension {
                type uint16;
                description
                  "MAC Flag Extension";
              }

              leaf vni {
                type uint32;
                description
                  "VNI Information";
              }
            }  // list l2fibmac-hardware-ingress
          }  // container l2fibmac-hardware-ingresses

          container l2fib-evpn-ip4macs {
            description
              "EVPN IPv4-MAC Table";
            list l2fib-evpn-ip4mac {
              description
                "The attributes for a particular EVPN IPv4-MAC
               Entry";
              leaf bdid {
                type Bridge-id-range;
                description "BD ID";
              }

              leaf ip-address {
                type inet:ip-address-no-zone;
                description "IP Address";
              }

              leaf is-local {
                type boolean;
                description
                  "Entry is locally learned";
              }

              leaf mac-address {
                type yang:mac-address;
                description "MAC Address";
              }

              container ip-address-xr {
                description "IP Address";
                leaf addr-type {
                  type L2fib-ip-addr;
                  description "addr type";
                }

                leaf ip {
                  type inet:ipv6-address;
                  description "ip";
                }
              }  // container ip-address-xr

              leaf bdid-xr {
                type uint32;
                description "BD ID";
              }

              leaf mac-address-xr {
                type yang:mac-address;
                description "MAC Address";
              }

              leaf arp-nd-sync-pending {
                type boolean;
                description
                  "Sync to ARP/ND Process Pending";
              }

              leaf arp-nd-probe-pending {
                type boolean;
                description
                  "Probe to ARP/ND Process Pending";
              }

              leaf arp-nd-delete-pending {
                type boolean;
                description
                  "Delete to ARP/ND Process Pending";
              }

              leaf is-local-xr {
                type boolean;
                description
                  "IP-MAC Route is locally learned";
              }
            }  // list l2fib-evpn-ip4mac
          }  // container l2fib-evpn-ip4macs

          container l2fib-pwhe-main-ports {
            description
              "PWHE Main-port table";
            list l2fib-pwhe-main-port {
              key "interface-name";
              description "PWHE Main-port";
              leaf interface-name {
                type xr:Interface-name;
                description "PWHE Main-port";
              }

              leaf next-hop-valid {
                type boolean;
                description
                  "IS Next Hop Valid";
              }

              leaf next-hop-address {
                type inet:ipv4-address;
                description
                  "Next Hop Address";
              }

              leaf pseudo-wire-type {
                type uint32;
                description
                  "Pseudowire type";
              }

              leaf generic-interface-list-id {
                type uint32;
                description
                  "Generic Interface List ID";
              }

              leaf internal-label {
                type uint32;
                description "Internal label";
              }

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

              leaf control-word-enabled {
                type boolean;
                description
                  "Control Word Enabled";
              }
            }  // list l2fib-pwhe-main-port
          }  // container l2fib-pwhe-main-ports

          container l2fib-dhcp-binding-count {
            description
              "DHCP binding forwarding total count";
            leaf bindings {
              type uint32;
              description
                "DHCP binding count";
            }
          }  // container l2fib-dhcp-binding-count

          container l2fib-bridge-domains {
            description
              "Bridge Domain forwarding detail";
            list l2fib-bridge-domain {
              description
                "Specify Bridge Domain Name";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Name of the Bridge group";
              }

              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              container oper {
                description
                  "Operational information";
                container operational-information {
                  description
                    "L2 operational information";
                  leaf mtu {
                    type uint32;
                    description "MTU";
                  }

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

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

                  leaf number-of-macs {
                    type uint32;
                    description
                      "numberOfMacs";
                  }

                  leaf admin-disabled {
                    type boolean;
                    description
                      "Is administratively disabled";
                  }

                  leaf flooding-disabled {
                    type boolean;
                    description
                      "Is flooding disabled";
                  }

                  leaf flood-unknown-unicast-enabled {
                    type boolean;
                    description
                      "Is flooding unknown unicast disabled";
                  }

                  leaf mac-limit-action {
                    type Mgmt-l2fib-mac-limit-action;
                    description
                      "MAC limit action";
                  }

                  leaf mac-limit-threshold {
                    type uint32;
                    units "percentage";
                    description
                      "MAC limit percentage recovery threshold";
                  }

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

                  leaf mac-port-down-flush-disabled {
                    type boolean;
                    description
                      "Is MAC port down flush disabled";
                  }

                  leaf mac-limit-notification-type {
                    type Mgmt-l2fib-mac-limit-notify;
                    description
                      "MAC limit notification";
                  }

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

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

                  leaf mac-secure-action {
                    type Mgmt-l2fib-mac-sec-action;
                    description
                      "MAC secure action";
                  }

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

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

                  leaf mac-aging-type {
                    type Mgmt-l2fib-mac-aging;
                    description
                      "MAC aging type";
                  }

                  leaf l2mc-src-traffic-enabled {
                    type uint32;
                    description
                      "L2MC Source Traffic Enabled";
                  }

                  leaf storm-control-unicast-enabled {
                    type boolean;
                    description
                      "Is unicast storm control enabled";
                  }

                  leaf storm-control-broadcast-enabled {
                    type boolean;
                    description
                      "Is broadcast storm control enabled";
                  }

                  leaf storm-control-multicast-enabled {
                    type boolean;
                    description
                      "Is multicast storm control enabled";
                  }

                  leaf storm-control-unicast-rate-unit {
                    type L2fib-storm-control-rate-unit;
                    description
                      "Storm control unicast rate unit";
                  }

                  leaf storm-control-broadcast-rate-unit {
                    type L2fib-storm-control-rate-unit;
                    description
                      "Storm control broadcast rate unit";
                  }

                  leaf storm-control-multicast-rate-unit {
                    type L2fib-storm-control-rate-unit;
                    description
                      "Storm control multicast rate unit";
                  }

                  leaf dhcp-enabled {
                    type boolean;
                    description
                      "Is DHCP snooping enabled";
                  }

                  leaf dhcp-trusted {
                    type boolean;
                    description
                      "Is DHCP trusted";
                  }

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

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

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

                  leaf is-dai-addr-validation-destination-mac-enabled {
                    type boolean;
                    description
                      "Is DAI Destination MAC Validation enabled";
                  }

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

                  leaf is-ipsg-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-vpls-flood-optimization-enabled {
                    type boolean;
                    description
                      "Is MMRP  Flood Optimization Enabled";
                  }

                  leaf igmp-snoop-enabled {
                    type boolean;
                    description
                      "Is IGMP snooping enabled";
                  }

                  leaf igmp-snoop-profile-enabled {
                    type boolean;
                    description
                      "Is IGMP snooping profile enabled";
                  }

                  leaf igmp-flood-forward-enabled {
                    type boolean;
                    description
                      "Is IGMP flood forwarding enabled";
                  }

                  leaf igmp-mroute-port-enabled {
                    type boolean;
                    description
                      "Is mrouter port";
                  }

                  leaf igmp-route-guard-enabled {
                    type boolean;
                    description
                      "Is router gurad enabled";
                  }

                  leaf mld-snoop-enabled {
                    type boolean;
                    description
                      "Is MLD snooping enabled";
                  }

                  leaf mld-snoop-profile-enabled {
                    type boolean;
                    description
                      "Is MLD snooping profile enabled";
                  }

                  leaf mld-flood-forward-enabled {
                    type boolean;
                    description
                      "Is MLD flood forwarding enabled";
                  }

                  leaf mld-mroute-port-enabled {
                    type boolean;
                    description
                      "Is mrouter port";
                  }

                  leaf mld-route-guard-enabled {
                    type boolean;
                    description
                      "Is router gurad enabled";
                  }

                  leaf stp-participating {
                    type boolean;
                    description
                      "Is Spanning Tree Protocol participating";
                  }

                  leaf bvi-configured {
                    type boolean;
                    description
                      "Is BVI Interface configured";
                  }

                  leaf is-bvi-up {
                    type boolean;
                    description
                      "Is BVI state UP";
                  }

                  leaf is-vni-enabled {
                    type boolean;
                    description
                      "Is VNI enabled";
                  }

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

                  leaf unknown-unicast-flooding-disabled {
                    type boolean;
                    description
                      "Unknown Unicast Flooding is disabled";
                  }

                  leaf is-pbbevpn-enabled {
                    type boolean;
                    description
                      "Is PBBEVPN enabled";
                  }

                  leaf is-swmac-learning {
                    type boolean;
                    description
                      "Is SW MAC learning enabled";
                  }

                  leaf is-evpn-flow-label {
                    type boolean;
                    description
                      "Is EVPN Flow Label enabled";
                  }

                  leaf is-evpn-cw-disable {
                    type boolean;
                    description
                      "Is EVPN CW disabled";
                  }

                  leaf msti {
                    type uint32;
                    description
                      "Multi-spanning tree instance";
                  }

                  leaf is-p2mp-pw-enabled {
                    type boolean;
                    description
                      "Is P2MP PW enabled";
                  }

                  leaf is-igmp-snoop-enabled {
                    type boolean;
                    description
                      "Is IGMP Snooping admin enabled";
                  }

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

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

                  leaf is-ves {
                    type boolean;
                    description
                      "Is Virtual Ethernet Segement feature enabled";
                  }

                  list feature {
                    description
                      "Feature information";
                    container dhcp {
                      when
                        "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                        description
                          "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                      }
                      description "dhcp";
                      leaf profile-name {
                        type string;
                        description
                          "Feature profile name";
                      }
                    }  // container dhcp

                    container igmp {
                      when
                        "../feature-type = 'l2fib-feature-igmp-snooping'" {
                        description
                          "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                      }
                      description "igmp";
                      leaf profile-name {
                        type string;
                        description
                          "Feature profile name";
                      }
                    }  // container igmp

                    container mld {
                      when
                        "../feature-type = 'l2fib-feature-mld-snooping'" {
                        description
                          "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                      }
                      description "mld";
                      leaf profile-name {
                        type string;
                        description
                          "Feature profile name";
                      }
                    }  // container mld

                    leaf feature-type {
                      type L2fib-feature;
                      description
                        "feature type";
                    }
                  }  // list feature
                }  // container operational-information

                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 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 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";
                }
              }  // container oper

              container bd-pbb-union {
                description
                  "Union of bridge Edge and Core info";
                container edge {
                  when
                    "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-edge'" {
                    description
                      "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_EDGE'";
                  }
                  description "edge";
                  leaf i-sid {
                    type uint32;
                    description "I SID";
                  }

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

                  leaf mirp-lite-rx {
                    type uint64;
                    description
                      "MIRP-lite Rx packet counter";
                  }

                  leaf mirp-lite-tx {
                    type uint64;
                    description
                      "MIRP-lite Tx packet counter";
                  }
                }  // container edge

                container core {
                  when
                    "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-core'" {
                    description
                      "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_CORE'";
                  }
                  description "core";
                  leaf nber-edge-bd {
                    type uint32;
                    description
                      "Number of associated pbb-edge Bds";
                  }
                }  // container core

                leaf pbb-type {
                  type Mgmt-l2fib-bridge;
                  description "PbbType";
                }
              }  // container bd-pbb-union

              container bvi-info {
                description
                  "BVI Information";
                leaf bvi-ifh {
                  type xr:Interface-name;
                  description
                    "BVI interface handle";
                }

                leaf bvi-xid {
                  type uint32;
                  description
                    "BVI xconnect id";
                }

                leaf bvi-name {
                  type string {
                    length "0..65";
                  }
                  description "BVI name";
                }

                leaf bvi-shg-id {
                  type uint32;
                  description
                    "BVI Split Horizon Group ID";
                }

                leaf irb-plat-data-len {
                  type uint32;
                  units "byte";
                  description
                    "Platform data bytes";
                }

                leaf irb-plat-data {
                  type yang:hex-string;
                  description
                    "IRB platform data";
                }
              }  // container bvi-info

              container p2mppw-info {
                description
                  "P2MP PW Information";
                container parent-next-hop {
                  description
                    "Parent Next Hop for P2MP PW";
                  leaf type {
                    type L2fib-nhop;
                    description
                      "Nexthop Type";
                  }

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "NHOP Address";
                  }

                  leaf next-hop-address-v6 {
                    type inet:ipv6-address;
                    description
                      "NHOP Address V6";
                  }

                  leaf next-hop-te-interface-name {
                    type xr:Interface-name;
                    description
                      "NHOP (SR-)TE Interface";
                  }

                  leaf next-hop-lsm-id {
                    type uint32;
                    description
                      "NHOP LSM ID";
                  }

                  leaf next-hop-sr-te-bsid {
                    type uint32;
                    description
                      "NHOP SR-TE Binding Label (BSID)";
                  }

                  leaf next-hop-internal-label {
                    type uint32;
                    description
                      "NHOP Internal Label";
                  }

                  leaf next-hop-internal-id {
                    type uint32;
                    description
                      "NHOP Internal ID";
                  }

                  leaf pin-down-interface-name {
                    type xr:Interface-name;
                    description
                      "Pin-down Interface Name";
                  }

                  leaf ecd-platform-data-valid {
                    type boolean;
                    description
                      "Is Platform ECD Data Valid";
                  }

                  leaf ecd-platform-data-length {
                    type uint32;
                    description
                      "Platform ECD Data Length";
                  }

                  leaf children-count {
                    type uint32;
                    description
                      "Children Count";
                  }

                  leaf children-evpn-ole-count {
                    type uint32;
                    description
                      "Children EVPN OLE Count";
                  }

                  leaf children-mac-count {
                    type uint32;
                    description
                      "Children MAC Count";
                  }

                  leaf children-pwhe-mp-count {
                    type uint32;
                    description
                      "Children PW-HE MainPort Count";
                  }

                  leaf children-ac-backup-count {
                    type uint32;
                    description
                      "Children AC-BACKUP Count";
                  }

                  leaf children-pw-ipv4-interface-list-count {
                    type uint32;
                    description
                      "Children PW IP-IFL Count";
                  }

                  leaf children-pw-te-tunnel-interface-list-count {
                    type uint32;
                    description
                      "Children PW IFH-IFL Count";
                  }
                }  // container parent-next-hop

                leaf ptree-type {
                  type L2vpn-ptree;
                  description
                    "P2MP ptree type";
                }

                leaf lsm-id {
                  type uint32;
                  description "LSM id";
                }

                leaf p2mp-te-interface {
                  type xr:Interface-name;
                  description "P2MP TE ifh";
                }

                leaf parent-nh-valid {
                  type boolean;
                  description
                    "Is Parent NH Valid";
                }

                leaf parent-nh-bound {
                  type boolean;
                  description
                    "Is Parent NH Bound";
                }

                leaf local-label {
                  type uint32;
                  description "Local label";
                }
              }  // container p2mppw-info

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

              leaf bridge-port-count {
                type uint32;
                description
                  "Number of bridge ports";
              }

              leaf number-of-hwmac {
                type uint32;
                description
                  "Number of HW MAC addresses";
              }

              leaf number-of-swmac {
                type uint32;
                description
                  "Number of SW MAC addresses";
              }

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

              leaf shg-count {
                type uint32;
                description
                  "Number of split horizon groups";
              }

              leaf bridge-type {
                type Mgmt-l2fib-bridge;
                description "Bridge Type";
              }

              leaf learn-key {
                type uint8;
                description "Learn Key";
              }

              leaf vrf-id {
                type uint32;
                description "VRF ID";
              }
            }  // list l2fib-bridge-domain
          }  // container l2fib-bridge-domains

          container l2fib-mstp-summaries {
            description "MSTP Summary Table";
            list l2fib-mstp-summary {
              description
                "MSTP Summary information";
              leaf parent-interface {
                type xr:Interface-name;
                description
                  "Parent interface context";
              }

              leaf main-interface-type {
                type Evpn-main-interface;
                description
                  "Main port interface type";
              }

              leaf msti {
                type Msti-range;
                description "MSTI context";
              }

              leaf parent-interface-xr {
                type xr:Interface-name;
                description "main port ID";
              }

              leaf msti-xr {
                type uint32;
                description
                  "multi-spanning tree instance";
              }

              leaf state {
                type uint32;
                description "MSTI state";
              }

              leaf bridge-port-count {
                type uint32;
                description
                  "Number of bridge ports";
              }
            }  // list l2fib-mstp-summary
          }  // container l2fib-mstp-summaries

          container l2fib-resource-availability {
            description
              "Resource availability information";
            container shm-resource {
              description
                "Shared memory resource info";
              leaf oout-of-resource-mode {
                type uint32;
                description "OOR mode";
              }

              leaf maximum-available {
                type uint64;
                units "byte";
                description
                  "Maximum bytes available";
              }

              leaf average-available {
                type uint64;
                units "byte";
                description
                  "Average number of bytes available";
              }

              leaf average-utility {
                type uint64;
                description
                  "Average utilization";
              }
            }  // container shm-resource

            leaf overall-out-of-resource-mode {
              type uint32;
              description "Overall OOR mode";
            }

            leaf hardware-resource-mode-information {
              type yang:hex-string;
              description
                "Opaque hardware resource info";
            }

            list hardware-resource-mode {
              description
                "Hardware resource mode";
              leaf entry {
                type uint32;
                description
                  "Hardware resource mode";
              }
            }  // list hardware-resource-mode
          }  // container l2fib-resource-availability

          container l2fibmac-hardware-egresses {
            description
              "Bridge Hardware Egress information";
            list l2fibmac-hardware-egress {
              description
                "MAC Hardware Egress information";
              leaf address {
                type yang:mac-address;
                description
                  "Static MAC address";
              }

              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Group Name";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..27";
                }
                description
                  "Bridge Domain Name";
              }

              container segment {
                description "Segment";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  leaf interface-name {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  leaf vsp-vlan {
                    type uint16;
                    description
                      "VLAN-Switched Port VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf parent-if {
                    type xr:Interface-name;
                    description
                      "Parent NVE Interface";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }
                }  // container evpn

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "pw";
                  leaf pw-id {
                    type uint64;
                    description
                      "Pseudowire ID";
                  }

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

                  leaf pseudo-wire-id-type {
                    type L2fib-pw-id;
                    description
                      "Pseudowire ID type";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment

              container evpn-ctx {
                description "Evpn Context";
                container mcast-ole {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-moi'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_MOI'";
                  }
                  description "mcast ole";
                  leaf tunnel-endpoint-id {
                    type uint32;
                    description
                      "Tunnel Endpoint ID";
                  }

                  leaf mcast-encapsulation {
                    type uint32;
                    description
                      "Inclusive mcast transport encap";
                  }

                  leaf moi-type {
                    type L2vpn-evpn-moi;
                    description
                      "MOI Next Hop type";
                  }

                  leaf next-hop-ipv6-addr {
                    type inet:ipv6-address;
                    description
                      "Next Hop IPv6 address";
                  }

                  leaf mcast-label {
                    type uint32;
                    description
                      "Inclusive mcast label";
                  }

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

                  leaf sr-te-bsid {
                    type uint32;
                    description
                      "SR-TE Binding Label (BSID)";
                  }

                  leaf srv6-te-bsid {
                    type inet:ipv6-address;
                    description
                      "SRv6-TE Binding SID";
                  }
                }  // container mcast-ole

                leaf data-type {
                  type Mgmt-l2fib-bridge-mac-evpn-ctx;
                  description "DataType";
                }

                leaf esi-id {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-esi-id'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_ESI_ID'";
                  }
                  type uint16;
                  description "EsiID";
                }

                leaf local-label {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-local-label'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_LOCAL_LABEL'";
                  }
                  type uint32;
                  description "LocalLabel";
                }

                leaf bp-ifh {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-bp-ifh'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_BP_IFH'";
                  }
                  type xr:Interface-name;
                  description "BP IFH";
                }

                leaf internal-id {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-internal-id'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_INTERNAL_ID'";
                  }
                  type uint32;
                  description "InternalID";
                }
              }  // container evpn-ctx

              container next-hop {
                description "Next Hop";
                leaf type {
                  type L2fib-nhop;
                  description "Nexthop Type";
                }

                leaf next-hop-address {
                  type inet:ipv4-address;
                  description "NHOP Address";
                }

                leaf next-hop-address-v6 {
                  type inet:ipv6-address;
                  description
                    "NHOP Address V6";
                }

                leaf next-hop-te-interface-name {
                  type xr:Interface-name;
                  description
                    "NHOP (SR-)TE Interface";
                }

                leaf next-hop-lsm-id {
                  type uint32;
                  description "NHOP LSM ID";
                }

                leaf next-hop-sr-te-bsid {
                  type uint32;
                  description
                    "NHOP SR-TE Binding Label (BSID)";
                }

                leaf next-hop-internal-label {
                  type uint32;
                  description
                    "NHOP Internal Label";
                }

                leaf next-hop-internal-id {
                  type uint32;
                  description
                    "NHOP Internal ID";
                }

                leaf pin-down-interface-name {
                  type xr:Interface-name;
                  description
                    "Pin-down Interface Name";
                }

                leaf ecd-platform-data-valid {
                  type boolean;
                  description
                    "Is Platform ECD Data Valid";
                }

                leaf ecd-platform-data-length {
                  type uint32;
                  description
                    "Platform ECD Data Length";
                }

                leaf children-count {
                  type uint32;
                  description
                    "Children Count";
                }

                leaf children-evpn-ole-count {
                  type uint32;
                  description
                    "Children EVPN OLE Count";
                }

                leaf children-mac-count {
                  type uint32;
                  description
                    "Children MAC Count";
                }

                leaf children-pwhe-mp-count {
                  type uint32;
                  description
                    "Children PW-HE MainPort Count";
                }

                leaf children-ac-backup-count {
                  type uint32;
                  description
                    "Children AC-BACKUP Count";
                }

                leaf children-pw-ipv4-interface-list-count {
                  type uint32;
                  description
                    "Children PW IP-IFL Count";
                }

                leaf children-pw-te-tunnel-interface-list-count {
                  type uint32;
                  description
                    "Children PW IFH-IFL Count";
                }
              }  // container next-hop

              leaf platform-is-hw-learn {
                type uint8;
                description
                  "Platform is HW Learn";
              }

              leaf node-id {
                type xr:Node-id;
                description "Nodeid list";
              }

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

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

              leaf bmac-configured {
                type boolean;
                description
                  "Flag: Configured BMAC";
              }

              leaf vni-l3-flag {
                type boolean;
                description "Flag: L3 Vxlan";
              }

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

              leaf l3-encapsulationvlan-id {
                type uint16;
                description
                  "L3 encapsulation Vlan ID";
              }

              leaf next-hop-valid {
                type boolean;
                description
                  "IS Next Hop Valid";
              }

              leaf peer-vtep-ip {
                type inet:ipv4-address;
                description
                  "Peer VTEP IP for this MAC Address";
              }

              leaf flag-extension {
                type uint16;
                description
                  "MAC Flag Extension";
              }

              leaf vni {
                type uint32;
                description
                  "VNI Information";
              }
            }  // list l2fibmac-hardware-egress
          }  // container l2fibmac-hardware-egresses

          container l2fib-evpn-incl-mcast-leaf-hardware-ingresses {
            description
              "L2FIB hardware egress EVPN inclusive multicast
             leaf table";
            list l2fib-evpn-incl-mcast-leaf-hardware-ingress {
              description
                "L2FIB hardware ingress EVPN inclusive
               multicast leaf";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Name of the Bridge group";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf xcid {
                type xr:Hex-integer;
                description "XC ID";
              }

              container l2fib-evpn-incl-mcast-oles {
                description
                  "L2FIB EVPN inclusive multicast output list
element table";
                list l2fib-evpn-incl-mcast-ole {
                  description
                    "L2FIB EVPN inclusive multicast output list
element";
                  leaf moi-type {
                    type L2fib-evpn-moi;
                    description
                      "EVPN MOI Type";
                  }

                  leaf next-hop-address {
                    type inet:ip-address-no-zone;
                    description
                      "Next Hop Address";
                  }

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

                  leaf sr-te-bsid {
                    type uint32 {
                      range "0..1048575";
                    }
                    description
                      "SR-TE Binding Label (BSID)";
                  }

                  leaf srv6-te-bsid {
                    type inet:ip-address-no-zone;
                    description
                      "SRv6-TE Binding SID";
                  }

                  container mcast-ole {
                    description
                      "Mcast Ole Info";
                    leaf tunnel-endpoint-id {
                      type uint32;
                      description
                        "Tunnel Endpoint ID";
                    }

                    leaf mcast-encapsulation {
                      type uint32;
                      description
                        "Inclusive mcast transport encap";
                    }

                    leaf moi-type {
                      type L2vpn-evpn-moi;
                      description
                        "MOI Next Hop type";
                    }

                    leaf next-hop-ipv6-addr {
                      type inet:ipv6-address;
                      description
                        "Next Hop IPv6 address";
                    }

                    leaf mcast-label {
                      type uint32;
                      description
                        "Inclusive mcast label";
                    }

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

                    leaf sr-te-bsid {
                      type uint32;
                      description
                        "SR-TE Binding Label (BSID)";
                    }

                    leaf srv6-te-bsid {
                      type inet:ipv6-address;
                      description
                        "SRv6-TE Binding SID";
                    }
                  }  // container mcast-ole

                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  leaf is-bound {
                    type boolean;
                    description "Is bound";
                  }

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

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }
                }  // list l2fib-evpn-incl-mcast-ole
              }  // container l2fib-evpn-incl-mcast-oles

              container l2fib-evpn-incl-mcast-leaf-info {
                description
                  "L2FIB EVPN inclusive multicast leaf information";
                leaf bridge-domain-name {
                  type string;
                  description
                    "Bridge-domain name";
                }

                leaf bridge-domain-id {
                  type uint32;
                  description "bdid value";
                }

                leaf xcid {
                  type uint32;
                  description "xcid value";
                }

                leaf is-bound {
                  type boolean;
                  description "Is bound";
                }
              }  // container l2fib-evpn-incl-mcast-leaf-info
            }  // list l2fib-evpn-incl-mcast-leaf-hardware-ingress
          }  // container l2fib-evpn-incl-mcast-leaf-hardware-ingresses

          container l2fibx-con-l2tpv2s {
            description
              "The L2VPN forwarding XConnect L2TPv2 Detail
             Table";
            list l2fibx-con-l2tpv2 {
              description "Specify Sub Ifh";
              leaf interface-name {
                type xr:Interface-name;
                description "Interface Name";
              }

              leaf vsp-vlan-id {
                type uint32 {
                  range "0..4094";
                }
                description
                  "VLAN-Switched Port VLAN ID";
              }

              container segment1 {
                description
                  "Segment1 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  container pbb-union {
                    description
                      "Union of Edge and Core";
                    container edge {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-edge'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_EDGE'";
                      }
                      description "edge";
                      leaf mac-configured {
                        type boolean;
                        description
                          "Configured MAC";
                      }

                      leaf mac {
                        type yang:mac-address;
                        description
                          "unknown unicast bmac";
                      }
                    }  // container edge

                    container core {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-core'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_CORE'";
                      }
                      description "core";
                      leaf vlan-id {
                        type uint32;
                        description
                          "vlan id";
                      }
                    }  // container core

                    leaf pbb-type {
                      type Mgmt-l2fib-bridge;
                      description "PbbType";
                    }
                  }  // container pbb-union

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf core-pbb-evpn-enabled {
                    type boolean;
                    description
                      "Core PBB-EVPN enabled";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf srcip {
                    type inet:ipv4-address;
                    description
                      "VNI Src IPv4 Address";
                  }

                  leaf mcastip {
                    type inet:ipv4-address;
                    description
                      "VNI Mcast IP Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf encap {
                    type uint32;
                    description
                      "Encap type of VNI";
                  }

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

                  leaf source-vtep-if {
                    type xr:Interface-name;
                    description
                      "Source IF Handle";
                  }

                  leaf any-cast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast VTEP IP";
                  }

                  leaf anycast-mcast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast Multicast IP";
                  }

                  leaf ingress-replication {
                    type boolean;
                    description
                      "Ingress Replication supported on VNI";
                  }

                  leaf vx-lan-mode {
                    type uint32;
                    description "Vxlan mode";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evi {
                    type uint32;
                    description "EVPN ID";
                  }

                  leaf forward-class {
                    type uint8;
                    description
                      "Forward Class";
                  }
                }  // container evpn

                container monitor-session {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description
                    "monitor session";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf session-name {
                    type string;
                    description
                      "Monitor Session Name";
                  }

                  leaf hardware-information {
                    type yang:hex-string;
                    description
                      "hardware Information of Monitor Session";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }
                }  // container monitor-session

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn' and ../data-type != 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN' and
../DataType != 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment1

              container segment2 {
                description
                  "Segment2 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container bp {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-bridge-port'" {
                    description
                      "../DataType =
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT'";
                  }
                  description "bp";
                  container oper {
                    description
                      "Operational information";
                    container operational-information {
                      description
                        "L2 operational information";
                      leaf mtu {
                        type uint32;
                        description "MTU";
                      }

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

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

                      leaf number-of-macs {
                        type uint32;
                        description
                          "numberOfMacs";
                      }

                      leaf admin-disabled {
                        type boolean;
                        description
                          "Is administratively disabled";
                      }

                      leaf flooding-disabled {
                        type boolean;
                        description
                          "Is flooding disabled";
                      }

                      leaf flood-unknown-unicast-enabled {
                        type boolean;
                        description
                          "Is flooding unknown unicast disabled";
                      }

                      leaf mac-limit-action {
                        type Mgmt-l2fib-mac-limit-action;
                        description
                          "MAC limit action";
                      }

                      leaf mac-limit-threshold {
                        type uint32;
                        units "percentage";
                        description
                          "MAC limit percentage recovery threshold";
                      }

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

                      leaf mac-port-down-flush-disabled {
                        type boolean;
                        description
                          "Is MAC port down flush disabled";
                      }

                      leaf mac-limit-notification-type {
                        type Mgmt-l2fib-mac-limit-notify;
                        description
                          "MAC limit notification";
                      }

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

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

                      leaf mac-secure-action {
                        type Mgmt-l2fib-mac-sec-action;
                        description
                          "MAC secure action";
                      }

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

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

                      leaf mac-aging-type {
                        type Mgmt-l2fib-mac-aging;
                        description
                          "MAC aging type";
                      }

                      leaf l2mc-src-traffic-enabled {
                        type uint32;
                        description
                          "L2MC Source Traffic Enabled";
                      }

                      leaf storm-control-unicast-enabled {
                        type boolean;
                        description
                          "Is unicast storm control enabled";
                      }

                      leaf storm-control-broadcast-enabled {
                        type boolean;
                        description
                          "Is broadcast storm control enabled";
                      }

                      leaf storm-control-multicast-enabled {
                        type boolean;
                        description
                          "Is multicast storm control enabled";
                      }

                      leaf storm-control-unicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control unicast rate unit";
                      }

                      leaf storm-control-broadcast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control broadcast rate unit";
                      }

                      leaf storm-control-multicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control multicast rate unit";
                      }

                      leaf dhcp-enabled {
                        type boolean;
                        description
                          "Is DHCP snooping enabled";
                      }

                      leaf dhcp-trusted {
                        type boolean;
                        description
                          "Is DHCP trusted";
                      }

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

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

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

                      leaf is-dai-addr-validation-destination-mac-enabled {
                        type boolean;
                        description
                          "Is DAI Destination MAC Validation enabled";
                      }

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

                      leaf is-ipsg-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-vpls-flood-optimization-enabled {
                        type boolean;
                        description
                          "Is MMRP  Flood Optimization Enabled";
                      }

                      leaf igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping enabled";
                      }

                      leaf igmp-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping profile enabled";
                      }

                      leaf igmp-flood-forward-enabled {
                        type boolean;
                        description
                          "Is IGMP flood forwarding enabled";
                      }

                      leaf igmp-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf igmp-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf mld-snoop-enabled {
                        type boolean;
                        description
                          "Is MLD snooping enabled";
                      }

                      leaf mld-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is MLD snooping profile enabled";
                      }

                      leaf mld-flood-forward-enabled {
                        type boolean;
                        description
                          "Is MLD flood forwarding enabled";
                      }

                      leaf mld-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf mld-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf stp-participating {
                        type boolean;
                        description
                          "Is Spanning Tree Protocol participating";
                      }

                      leaf bvi-configured {
                        type boolean;
                        description
                          "Is BVI Interface configured";
                      }

                      leaf is-bvi-up {
                        type boolean;
                        description
                          "Is BVI state UP";
                      }

                      leaf is-vni-enabled {
                        type boolean;
                        description
                          "Is VNI enabled";
                      }

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

                      leaf unknown-unicast-flooding-disabled {
                        type boolean;
                        description
                          "Unknown Unicast Flooding is disabled";
                      }

                      leaf is-pbbevpn-enabled {
                        type boolean;
                        description
                          "Is PBBEVPN enabled";
                      }

                      leaf is-swmac-learning {
                        type boolean;
                        description
                          "Is SW MAC learning enabled";
                      }

                      leaf is-evpn-flow-label {
                        type boolean;
                        description
                          "Is EVPN Flow Label enabled";
                      }

                      leaf is-evpn-cw-disable {
                        type boolean;
                        description
                          "Is EVPN CW disabled";
                      }

                      leaf msti {
                        type uint32;
                        description
                          "Multi-spanning tree instance";
                      }

                      leaf is-p2mp-pw-enabled {
                        type boolean;
                        description
                          "Is P2MP PW enabled";
                      }

                      leaf is-igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP Snooping admin enabled";
                      }

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

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

                      leaf is-ves {
                        type boolean;
                        description
                          "Is Virtual Ethernet Segement feature enabled";
                      }

                      list feature {
                        description
                          "Feature information";
                        container dhcp {
                          when
                            "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                          }
                          description "dhcp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container dhcp

                        container igmp {
                          when
                            "../feature-type = 'l2fib-feature-igmp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                          }
                          description "igmp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container igmp

                        container mld {
                          when
                            "../feature-type = 'l2fib-feature-mld-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                          }
                          description "mld";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container mld

                        leaf feature-type {
                          type L2fib-feature;
                          description
                            "feature type";
                        }
                      }  // list feature
                    }  // container operational-information

                    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 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 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";
                    }
                  }  // container oper

                  container p2mp {
                    description
                      "BP P2MP PW Information";
                    leaf ptree-type {
                      type L2vpn-ptree;
                      description
                        "P2MP ptree type";
                    }

                    leaf lsm-id {
                      type uint32;
                      description
                        "MLDP LSM id";
                    }

                    leaf tunnel-id {
                      type uint16;
                      description
                        "TE Tunnel Id";
                    }

                    leaf p2mp-id {
                      type uint16;
                      description
                        "TE P2MP Id";
                    }

                    leaf extended-tunnel-id {
                      type inet:ipv4-address;
                      description
                        "TE Extended Tunnel Id";
                    }

                    leaf ptree-owner-lmrib {
                      type boolean;
                      description
                        "PTree Owner LMRIB";
                    }
                  }  // container p2mp

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

                  leaf shg-id {
                    type uint32;
                    description
                      "Split horizon group ID";
                  }

                  leaf msti-pointer {
                    type uint32;
                    description
                      "MSTI Pointer";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }

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

                  leaf learn-key {
                    type uint8;
                    description "Learn Key";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evpn-shg-local-label {
                    type uint32;
                    description
                      "EVPN split horizon group local label";
                  }

                  list evpn-shg-remote-info {
                    description
                      "EVPN split horizon group remote info";
                    container remote-split-horizon-group-label {
                      description
                        "Remote split horizon group label";
                      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";
                      }
                    }  // container remote-split-horizon-group-label
                  }  // list evpn-shg-remote-info
                }  // container bp

                container fxs {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "fxs";
                  leaf fxs-id {
                    type uint32;
                    description "FXS ID";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }
                }  // container fxs

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-bridge-port' and ../data-type != 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType !=
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment2

              leaf xcon-name {
                type string {
                  length "0..72";
                }
                description "Xconnect name";
              }

              leaf bound {
                type boolean;
                description "Bound";
              }

              leaf switching-type {
                type Mgmt-l2fib-switching;
                description "SW Type";
              }
            }  // list l2fibx-con-l2tpv2
          }  // container l2fibx-con-l2tpv2s

          container l2fib-mroute-ipv6s {
            description
              "multicast information";
            list l2fib-mroute-ipv6 {
              description
                "Bridge Domain Multicast Information";
              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf source {
                type inet:ip-address-no-zone;
                description
                  "Source IPv6 Address";
              }

              leaf group {
                type inet:ip-address-no-zone;
                description
                  "Group IPv6 Address";
              }

              container source-prefix {
                description "Source Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container source-prefix

              container destination-prefix {
                description
                  "Destination Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container destination-prefix

              container forward-stats {
                description
                  "Forwarding Statistics";
                container forward-stat {
                  description "fwd stats";
                  container mulicast {
                    when
                      "../data-type = 'mgmt-l2fib-stats-type-mcast'" {
                      description
                        "../DataType = 'MGMT_L2FIB_STATS_TYPE_MCAST'";
                    }
                    description "mulicast";
                    container multicast-forward-stat {
                      description
                        "forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-forward-stat

                    container received-stat {
                      description
                        "received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container received-stat

                    container punt {
                      description
                        "punted stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container punt

                    container drop {
                      description
                        "dropped stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container drop

                    container multicast-core-forward-stat {
                      description
                        "core forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-core-forward-stat

                    container core-received-stat {
                      description
                        "core received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container core-received-stat
                  }  // container mulicast

                  leaf data-type {
                    type Mgmt-l2fib-stats-data;
                    description "DataType";
                  }
                }  // container forward-stat
              }  // container forward-stats

              container irb-info {
                description
                  "IRB Information";
                leaf mxid-ac-interface-handle {
                  type xr:Interface-name;
                  description
                    "Master XID AC If handle";
                }

                leaf mxid-pw-id {
                  type uint32;
                  description
                    "Master XID PW ID";
                }

                leaf mxid-next-hop-address {
                  type inet:ipv4-address;
                  description
                    "Master XID NHOP IP Address";
                }

                leaf irb-plat-data-len {
                  type uint16;
                  units "byte";
                  description
                    "Platform data bytes";
                }

                list irb-plat-data {
                  max-elements 16;
                  description
                    "IRB platform data";
                  leaf entry {
                    type uint32;
                    description
                      "IRB platform data";
                  }
                }  // list irb-plat-data
              }  // container irb-info

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

              leaf xid-count {
                type uint16;
                description "Count of XIDs";
              }

              leaf platform-data-length {
                type uint8;
                description
                  "The mcast platform data len";
              }

              leaf platform-data {
                type yang:hex-string;
                description
                  "The mcast platform data";
              }

              leaf hardware-information {
                type yang:hex-string;
                description
                  "Platform Hardware info";
              }

              leaf bridge-domain-name {
                type string {
                  length "0..66";
                }
                description "Bridge Name";
              }
            }  // list l2fib-mroute-ipv6
          }  // container l2fib-mroute-ipv6s

          container l2fib-mon-sess-x-cons {
            description
              "The L2VPN forwarding Monitor Session XConnect
             Information";
            list l2fib-mon-sess-x-con {
              key "monitor-session-name";
              description
                "Specify Monitor Session Name";
              leaf monitor-session-name {
                type xr:Cisco-ios-xr-string {
                  length "1..64";
                }
                description
                  "Monitor Session Name";
              }

              container segment1 {
                description
                  "Segment1 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  container pbb-union {
                    description
                      "Union of Edge and Core";
                    container edge {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-edge'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_EDGE'";
                      }
                      description "edge";
                      leaf mac-configured {
                        type boolean;
                        description
                          "Configured MAC";
                      }

                      leaf mac {
                        type yang:mac-address;
                        description
                          "unknown unicast bmac";
                      }
                    }  // container edge

                    container core {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-core'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_CORE'";
                      }
                      description "core";
                      leaf vlan-id {
                        type uint32;
                        description
                          "vlan id";
                      }
                    }  // container core

                    leaf pbb-type {
                      type Mgmt-l2fib-bridge;
                      description "PbbType";
                    }
                  }  // container pbb-union

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf core-pbb-evpn-enabled {
                    type boolean;
                    description
                      "Core PBB-EVPN enabled";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf srcip {
                    type inet:ipv4-address;
                    description
                      "VNI Src IPv4 Address";
                  }

                  leaf mcastip {
                    type inet:ipv4-address;
                    description
                      "VNI Mcast IP Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf encap {
                    type uint32;
                    description
                      "Encap type of VNI";
                  }

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

                  leaf source-vtep-if {
                    type xr:Interface-name;
                    description
                      "Source IF Handle";
                  }

                  leaf any-cast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast VTEP IP";
                  }

                  leaf anycast-mcast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast Multicast IP";
                  }

                  leaf ingress-replication {
                    type boolean;
                    description
                      "Ingress Replication supported on VNI";
                  }

                  leaf vx-lan-mode {
                    type uint32;
                    description "Vxlan mode";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evi {
                    type uint32;
                    description "EVPN ID";
                  }

                  leaf forward-class {
                    type uint8;
                    description
                      "Forward Class";
                  }
                }  // container evpn

                container monitor-session {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description
                    "monitor session";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf session-name {
                    type string;
                    description
                      "Monitor Session Name";
                  }

                  leaf hardware-information {
                    type yang:hex-string;
                    description
                      "hardware Information of Monitor Session";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }
                }  // container monitor-session

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn' and ../data-type != 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN' and
../DataType != 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment1

              container segment2 {
                description
                  "Segment2 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container bp {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-bridge-port'" {
                    description
                      "../DataType =
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT'";
                  }
                  description "bp";
                  container oper {
                    description
                      "Operational information";
                    container operational-information {
                      description
                        "L2 operational information";
                      leaf mtu {
                        type uint32;
                        description "MTU";
                      }

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

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

                      leaf number-of-macs {
                        type uint32;
                        description
                          "numberOfMacs";
                      }

                      leaf admin-disabled {
                        type boolean;
                        description
                          "Is administratively disabled";
                      }

                      leaf flooding-disabled {
                        type boolean;
                        description
                          "Is flooding disabled";
                      }

                      leaf flood-unknown-unicast-enabled {
                        type boolean;
                        description
                          "Is flooding unknown unicast disabled";
                      }

                      leaf mac-limit-action {
                        type Mgmt-l2fib-mac-limit-action;
                        description
                          "MAC limit action";
                      }

                      leaf mac-limit-threshold {
                        type uint32;
                        units "percentage";
                        description
                          "MAC limit percentage recovery threshold";
                      }

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

                      leaf mac-port-down-flush-disabled {
                        type boolean;
                        description
                          "Is MAC port down flush disabled";
                      }

                      leaf mac-limit-notification-type {
                        type Mgmt-l2fib-mac-limit-notify;
                        description
                          "MAC limit notification";
                      }

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

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

                      leaf mac-secure-action {
                        type Mgmt-l2fib-mac-sec-action;
                        description
                          "MAC secure action";
                      }

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

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

                      leaf mac-aging-type {
                        type Mgmt-l2fib-mac-aging;
                        description
                          "MAC aging type";
                      }

                      leaf l2mc-src-traffic-enabled {
                        type uint32;
                        description
                          "L2MC Source Traffic Enabled";
                      }

                      leaf storm-control-unicast-enabled {
                        type boolean;
                        description
                          "Is unicast storm control enabled";
                      }

                      leaf storm-control-broadcast-enabled {
                        type boolean;
                        description
                          "Is broadcast storm control enabled";
                      }

                      leaf storm-control-multicast-enabled {
                        type boolean;
                        description
                          "Is multicast storm control enabled";
                      }

                      leaf storm-control-unicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control unicast rate unit";
                      }

                      leaf storm-control-broadcast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control broadcast rate unit";
                      }

                      leaf storm-control-multicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control multicast rate unit";
                      }

                      leaf dhcp-enabled {
                        type boolean;
                        description
                          "Is DHCP snooping enabled";
                      }

                      leaf dhcp-trusted {
                        type boolean;
                        description
                          "Is DHCP trusted";
                      }

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

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

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

                      leaf is-dai-addr-validation-destination-mac-enabled {
                        type boolean;
                        description
                          "Is DAI Destination MAC Validation enabled";
                      }

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

                      leaf is-ipsg-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-vpls-flood-optimization-enabled {
                        type boolean;
                        description
                          "Is MMRP  Flood Optimization Enabled";
                      }

                      leaf igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping enabled";
                      }

                      leaf igmp-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping profile enabled";
                      }

                      leaf igmp-flood-forward-enabled {
                        type boolean;
                        description
                          "Is IGMP flood forwarding enabled";
                      }

                      leaf igmp-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf igmp-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf mld-snoop-enabled {
                        type boolean;
                        description
                          "Is MLD snooping enabled";
                      }

                      leaf mld-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is MLD snooping profile enabled";
                      }

                      leaf mld-flood-forward-enabled {
                        type boolean;
                        description
                          "Is MLD flood forwarding enabled";
                      }

                      leaf mld-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf mld-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf stp-participating {
                        type boolean;
                        description
                          "Is Spanning Tree Protocol participating";
                      }

                      leaf bvi-configured {
                        type boolean;
                        description
                          "Is BVI Interface configured";
                      }

                      leaf is-bvi-up {
                        type boolean;
                        description
                          "Is BVI state UP";
                      }

                      leaf is-vni-enabled {
                        type boolean;
                        description
                          "Is VNI enabled";
                      }

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

                      leaf unknown-unicast-flooding-disabled {
                        type boolean;
                        description
                          "Unknown Unicast Flooding is disabled";
                      }

                      leaf is-pbbevpn-enabled {
                        type boolean;
                        description
                          "Is PBBEVPN enabled";
                      }

                      leaf is-swmac-learning {
                        type boolean;
                        description
                          "Is SW MAC learning enabled";
                      }

                      leaf is-evpn-flow-label {
                        type boolean;
                        description
                          "Is EVPN Flow Label enabled";
                      }

                      leaf is-evpn-cw-disable {
                        type boolean;
                        description
                          "Is EVPN CW disabled";
                      }

                      leaf msti {
                        type uint32;
                        description
                          "Multi-spanning tree instance";
                      }

                      leaf is-p2mp-pw-enabled {
                        type boolean;
                        description
                          "Is P2MP PW enabled";
                      }

                      leaf is-igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP Snooping admin enabled";
                      }

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

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

                      leaf is-ves {
                        type boolean;
                        description
                          "Is Virtual Ethernet Segement feature enabled";
                      }

                      list feature {
                        description
                          "Feature information";
                        container dhcp {
                          when
                            "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                          }
                          description "dhcp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container dhcp

                        container igmp {
                          when
                            "../feature-type = 'l2fib-feature-igmp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                          }
                          description "igmp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container igmp

                        container mld {
                          when
                            "../feature-type = 'l2fib-feature-mld-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                          }
                          description "mld";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container mld

                        leaf feature-type {
                          type L2fib-feature;
                          description
                            "feature type";
                        }
                      }  // list feature
                    }  // container operational-information

                    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 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 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";
                    }
                  }  // container oper

                  container p2mp {
                    description
                      "BP P2MP PW Information";
                    leaf ptree-type {
                      type L2vpn-ptree;
                      description
                        "P2MP ptree type";
                    }

                    leaf lsm-id {
                      type uint32;
                      description
                        "MLDP LSM id";
                    }

                    leaf tunnel-id {
                      type uint16;
                      description
                        "TE Tunnel Id";
                    }

                    leaf p2mp-id {
                      type uint16;
                      description
                        "TE P2MP Id";
                    }

                    leaf extended-tunnel-id {
                      type inet:ipv4-address;
                      description
                        "TE Extended Tunnel Id";
                    }

                    leaf ptree-owner-lmrib {
                      type boolean;
                      description
                        "PTree Owner LMRIB";
                    }
                  }  // container p2mp

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

                  leaf shg-id {
                    type uint32;
                    description
                      "Split horizon group ID";
                  }

                  leaf msti-pointer {
                    type uint32;
                    description
                      "MSTI Pointer";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }

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

                  leaf learn-key {
                    type uint8;
                    description "Learn Key";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evpn-shg-local-label {
                    type uint32;
                    description
                      "EVPN split horizon group local label";
                  }

                  list evpn-shg-remote-info {
                    description
                      "EVPN split horizon group remote info";
                    container remote-split-horizon-group-label {
                      description
                        "Remote split horizon group label";
                      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";
                      }
                    }  // container remote-split-horizon-group-label
                  }  // list evpn-shg-remote-info
                }  // container bp

                container fxs {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "fxs";
                  leaf fxs-id {
                    type uint32;
                    description "FXS ID";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }
                }  // container fxs

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-bridge-port' and ../data-type != 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType !=
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment2

              leaf xcon-name {
                type string {
                  length "0..72";
                }
                description "Xconnect name";
              }

              leaf bound {
                type boolean;
                description "Bound";
              }

              leaf switching-type {
                type Mgmt-l2fib-switching;
                description "SW Type";
              }
            }  // list l2fib-mon-sess-x-con
          }  // container l2fib-mon-sess-x-cons

          container l2fib-mmrp-summaries {
            description "Mmrp Summary Table";
            list l2fib-mmrp-summary {
              description
                "Mmrp Summary Information";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Group Name";
              }

              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf bridge-domain-name {
                type string {
                  length "0..66";
                }
                description "Bridge Name";
              }

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

              leaf multicast-update {
                type uint32;
                description
                  "Multicast Updates";
              }

              leaf multicast-update-dropped {
                type uint32;
                description
                  "Multicast Updates";
              }

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

              leaf number-of-routes-with-ole-offload {
                type uint32;
                description
                  "Number of Routes with OleOffload";
              }

              leaf number-of-mroute-add {
                type uint32;
                description
                  "Number of Mroutes Added";
              }

              leaf number-mroute-deleted {
                type uint32;
                description
                  "Number of Mroutes Deleted";
              }

              leaf number-mroutes-deleted-all {
                type uint32;
                description
                  "Number of Mroutes All Deleted";
              }

              leaf number-mroute-delete-drop {
                type uint32;
                description
                  "Number of Mroutes Delete droped";
              }

              leaf number-mroute-all-delete-drop {
                type uint32;
                description
                  "Number of Mroutes All Delete droped";
              }

              leaf number-xid-add {
                type uint32;
                description
                  "Number of XID Added";
              }

              leaf number-xid-deleted {
                type uint32;
                description
                  "Number of XID Deleted";
              }

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

              leaf stale-deleted {
                type uint32;
                description "Stale Deleted";
              }

              leaf stale-xid-deleted {
                type uint32;
                description
                  "Stale XID Deleted";
              }

              list message {
                description
                  "Global Message Information";
                leaf message-count {
                  type uint32;
                  description
                    "number of message";
                }

                leaf time {
                  type string;
                  description "Time string";
                }

                leaf information1 {
                  type uint32;
                  description "Extra info 1";
                }

                leaf information2 {
                  type uint32;
                  description "Extra info 2";
                }

                leaf description {
                  type string;
                  description
                    "Description of the message";
                }
              }  // list message
            }  // list l2fib-mmrp-summary
          }  // container l2fib-mmrp-summaries

          container l2fib-pw-groups {
            description
              "PW Group Table Information";
            list l2fib-pw-group {
              description
                "PW Group Information";
              leaf next-hop-type {
                type L2fib-next-hop-key;
                description "NHOP Type";
              }

              leaf peer-address {
                type inet:ipv4-address-no-zone;
                description
                  "Peer IP Address";
              }

              leaf group-id {
                type Pw-group-id-range;
                description "Group Id";
              }

              leaf next-hop-address {
                type inet:ipv4-address-no-zone;
                description "NHOP Address";
              }

              leaf next-hop-te-interface-name {
                type xr:Interface-name;
                description
                  "NHOP (SR-)TE Interface";
              }

              leaf next-hop-lsm-id {
                type Lsm-id-range;
                description "NHOP LSM ID";
              }

              leaf next-hop-address-v6 {
                type inet:ip-address-no-zone;
                description
                  "NHOP Address V6";
              }

              leaf next-hop-internal-label {
                type uint32 {
                  range "0..1048575";
                }
                description
                  "NHOP Internal Label";
              }

              leaf next-hop-sr-te-bsid {
                type uint32 {
                  range "0..1048575";
                }
                description
                  "NHOP SR-TE Binding Label (BSID)";
              }

              leaf next-hop-internal-id {
                type Rib-iid-range;
                description
                  "NHOP Internal ID";
              }

              leaf group-state {
                type L2fib-group-state;
                description "Group State";
              }

              leaf pw-list-count {
                type uint32;
                description
                  "Dependent PW List Count";
              }
            }  // list l2fib-pw-group
          }  // container l2fib-pw-groups

          container l2fib-dhcp-binding-details {
            description
              "DHCP binding forwarding detail";
            list l2fib-dhcp-binding-detail {
              description
                "Specify DHCP binding detail";
              leaf xcid {
                type xr:Hex-integer;
                description "XConnect ID";
              }

              leaf neighbor-address {
                type inet:ipv4-address-no-zone;
                description
                  "Neighbor IPv4 address";
              }

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

              container port {
                description
                  "Union of Port information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  leaf interface-name {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  leaf vsp-vlan {
                    type uint16;
                    description
                      "VLAN-Switched Port VLAN ID";
                  }
                }  // container ac

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "pw";
                  leaf pw-id {
                    type uint64;
                    description
                      "Pseudowire ID";
                  }

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

                  leaf pseudo-wire-id-type {
                    type L2fib-pw-id;
                    description
                      "Pseudowire ID type";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container port
            }  // list l2fib-dhcp-binding-detail
          }  // container l2fib-dhcp-binding-details

          container l2fibx-cons {
            description
              "The L2VPN forwarding XConnect Detail Table";
            list l2fibx-con {
              key "xcid";
              description
                "Specify XConnect ID";
              leaf xcid {
                type xr:Hex-integer;
                description "XC ID";
              }

              container segment1 {
                description
                  "Segment1 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  container pbb-union {
                    description
                      "Union of Edge and Core";
                    container edge {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-edge'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_EDGE'";
                      }
                      description "edge";
                      leaf mac-configured {
                        type boolean;
                        description
                          "Configured MAC";
                      }

                      leaf mac {
                        type yang:mac-address;
                        description
                          "unknown unicast bmac";
                      }
                    }  // container edge

                    container core {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-core'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_CORE'";
                      }
                      description "core";
                      leaf vlan-id {
                        type uint32;
                        description
                          "vlan id";
                      }
                    }  // container core

                    leaf pbb-type {
                      type Mgmt-l2fib-bridge;
                      description "PbbType";
                    }
                  }  // container pbb-union

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf core-pbb-evpn-enabled {
                    type boolean;
                    description
                      "Core PBB-EVPN enabled";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf srcip {
                    type inet:ipv4-address;
                    description
                      "VNI Src IPv4 Address";
                  }

                  leaf mcastip {
                    type inet:ipv4-address;
                    description
                      "VNI Mcast IP Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf encap {
                    type uint32;
                    description
                      "Encap type of VNI";
                  }

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

                  leaf source-vtep-if {
                    type xr:Interface-name;
                    description
                      "Source IF Handle";
                  }

                  leaf any-cast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast VTEP IP";
                  }

                  leaf anycast-mcast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast Multicast IP";
                  }

                  leaf ingress-replication {
                    type boolean;
                    description
                      "Ingress Replication supported on VNI";
                  }

                  leaf vx-lan-mode {
                    type uint32;
                    description "Vxlan mode";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evi {
                    type uint32;
                    description "EVPN ID";
                  }

                  leaf forward-class {
                    type uint8;
                    description
                      "Forward Class";
                  }
                }  // container evpn

                container monitor-session {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description
                    "monitor session";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf session-name {
                    type string;
                    description
                      "Monitor Session Name";
                  }

                  leaf hardware-information {
                    type yang:hex-string;
                    description
                      "hardware Information of Monitor Session";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }
                }  // container monitor-session

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn' and ../data-type != 'mgmt-l2fib-data-type-span'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN' and
../DataType != 'MGMT_L2FIB_DATA_TYPE_SPAN'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment1

              container segment2 {
                description
                  "Segment2 Information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container bp {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-bridge-port'" {
                    description
                      "../DataType =
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT'";
                  }
                  description "bp";
                  container oper {
                    description
                      "Operational information";
                    container operational-information {
                      description
                        "L2 operational information";
                      leaf mtu {
                        type uint32;
                        description "MTU";
                      }

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

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

                      leaf number-of-macs {
                        type uint32;
                        description
                          "numberOfMacs";
                      }

                      leaf admin-disabled {
                        type boolean;
                        description
                          "Is administratively disabled";
                      }

                      leaf flooding-disabled {
                        type boolean;
                        description
                          "Is flooding disabled";
                      }

                      leaf flood-unknown-unicast-enabled {
                        type boolean;
                        description
                          "Is flooding unknown unicast disabled";
                      }

                      leaf mac-limit-action {
                        type Mgmt-l2fib-mac-limit-action;
                        description
                          "MAC limit action";
                      }

                      leaf mac-limit-threshold {
                        type uint32;
                        units "percentage";
                        description
                          "MAC limit percentage recovery threshold";
                      }

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

                      leaf mac-port-down-flush-disabled {
                        type boolean;
                        description
                          "Is MAC port down flush disabled";
                      }

                      leaf mac-limit-notification-type {
                        type Mgmt-l2fib-mac-limit-notify;
                        description
                          "MAC limit notification";
                      }

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

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

                      leaf mac-secure-action {
                        type Mgmt-l2fib-mac-sec-action;
                        description
                          "MAC secure action";
                      }

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

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

                      leaf mac-aging-type {
                        type Mgmt-l2fib-mac-aging;
                        description
                          "MAC aging type";
                      }

                      leaf l2mc-src-traffic-enabled {
                        type uint32;
                        description
                          "L2MC Source Traffic Enabled";
                      }

                      leaf storm-control-unicast-enabled {
                        type boolean;
                        description
                          "Is unicast storm control enabled";
                      }

                      leaf storm-control-broadcast-enabled {
                        type boolean;
                        description
                          "Is broadcast storm control enabled";
                      }

                      leaf storm-control-multicast-enabled {
                        type boolean;
                        description
                          "Is multicast storm control enabled";
                      }

                      leaf storm-control-unicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control unicast rate unit";
                      }

                      leaf storm-control-broadcast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control broadcast rate unit";
                      }

                      leaf storm-control-multicast-rate-unit {
                        type L2fib-storm-control-rate-unit;
                        description
                          "Storm control multicast rate unit";
                      }

                      leaf dhcp-enabled {
                        type boolean;
                        description
                          "Is DHCP snooping enabled";
                      }

                      leaf dhcp-trusted {
                        type boolean;
                        description
                          "Is DHCP trusted";
                      }

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

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

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

                      leaf is-dai-addr-validation-destination-mac-enabled {
                        type boolean;
                        description
                          "Is DAI Destination MAC Validation enabled";
                      }

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

                      leaf is-ipsg-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-vpls-flood-optimization-enabled {
                        type boolean;
                        description
                          "Is MMRP  Flood Optimization Enabled";
                      }

                      leaf igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping enabled";
                      }

                      leaf igmp-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is IGMP snooping profile enabled";
                      }

                      leaf igmp-flood-forward-enabled {
                        type boolean;
                        description
                          "Is IGMP flood forwarding enabled";
                      }

                      leaf igmp-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf igmp-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf mld-snoop-enabled {
                        type boolean;
                        description
                          "Is MLD snooping enabled";
                      }

                      leaf mld-snoop-profile-enabled {
                        type boolean;
                        description
                          "Is MLD snooping profile enabled";
                      }

                      leaf mld-flood-forward-enabled {
                        type boolean;
                        description
                          "Is MLD flood forwarding enabled";
                      }

                      leaf mld-mroute-port-enabled {
                        type boolean;
                        description
                          "Is mrouter port";
                      }

                      leaf mld-route-guard-enabled {
                        type boolean;
                        description
                          "Is router gurad enabled";
                      }

                      leaf stp-participating {
                        type boolean;
                        description
                          "Is Spanning Tree Protocol participating";
                      }

                      leaf bvi-configured {
                        type boolean;
                        description
                          "Is BVI Interface configured";
                      }

                      leaf is-bvi-up {
                        type boolean;
                        description
                          "Is BVI state UP";
                      }

                      leaf is-vni-enabled {
                        type boolean;
                        description
                          "Is VNI enabled";
                      }

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

                      leaf unknown-unicast-flooding-disabled {
                        type boolean;
                        description
                          "Unknown Unicast Flooding is disabled";
                      }

                      leaf is-pbbevpn-enabled {
                        type boolean;
                        description
                          "Is PBBEVPN enabled";
                      }

                      leaf is-swmac-learning {
                        type boolean;
                        description
                          "Is SW MAC learning enabled";
                      }

                      leaf is-evpn-flow-label {
                        type boolean;
                        description
                          "Is EVPN Flow Label enabled";
                      }

                      leaf is-evpn-cw-disable {
                        type boolean;
                        description
                          "Is EVPN CW disabled";
                      }

                      leaf msti {
                        type uint32;
                        description
                          "Multi-spanning tree instance";
                      }

                      leaf is-p2mp-pw-enabled {
                        type boolean;
                        description
                          "Is P2MP PW enabled";
                      }

                      leaf is-igmp-snoop-enabled {
                        type boolean;
                        description
                          "Is IGMP Snooping admin enabled";
                      }

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

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

                      leaf is-ves {
                        type boolean;
                        description
                          "Is Virtual Ethernet Segement feature enabled";
                      }

                      list feature {
                        description
                          "Feature information";
                        container dhcp {
                          when
                            "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                          }
                          description "dhcp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container dhcp

                        container igmp {
                          when
                            "../feature-type = 'l2fib-feature-igmp-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                          }
                          description "igmp";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container igmp

                        container mld {
                          when
                            "../feature-type = 'l2fib-feature-mld-snooping'" {
                            description
                              "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                          }
                          description "mld";
                          leaf profile-name {
                            type string;
                            description
                              "Feature profile name";
                          }
                        }  // container mld

                        leaf feature-type {
                          type L2fib-feature;
                          description
                            "feature type";
                        }
                      }  // list feature
                    }  // container operational-information

                    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 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 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";
                    }
                  }  // container oper

                  container p2mp {
                    description
                      "BP P2MP PW Information";
                    leaf ptree-type {
                      type L2vpn-ptree;
                      description
                        "P2MP ptree type";
                    }

                    leaf lsm-id {
                      type uint32;
                      description
                        "MLDP LSM id";
                    }

                    leaf tunnel-id {
                      type uint16;
                      description
                        "TE Tunnel Id";
                    }

                    leaf p2mp-id {
                      type uint16;
                      description
                        "TE P2MP Id";
                    }

                    leaf extended-tunnel-id {
                      type inet:ipv4-address;
                      description
                        "TE Extended Tunnel Id";
                    }

                    leaf ptree-owner-lmrib {
                      type boolean;
                      description
                        "PTree Owner LMRIB";
                    }
                  }  // container p2mp

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

                  leaf shg-id {
                    type uint32;
                    description
                      "Split horizon group ID";
                  }

                  leaf msti-pointer {
                    type uint32;
                    description
                      "MSTI Pointer";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }

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

                  leaf learn-key {
                    type uint8;
                    description "Learn Key";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evpn-shg-local-label {
                    type uint32;
                    description
                      "EVPN split horizon group local label";
                  }

                  list evpn-shg-remote-info {
                    description
                      "EVPN split horizon group remote info";
                    container remote-split-horizon-group-label {
                      description
                        "Remote split horizon group label";
                      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";
                      }
                    }  // container remote-split-horizon-group-label
                  }  // list evpn-shg-remote-info
                }  // container bp

                container fxs {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "fxs";
                  leaf fxs-id {
                    type uint32;
                    description "FXS ID";
                  }

                  leaf segment-type {
                    type uint8;
                    description
                      "Segment type";
                  }
                }  // container fxs

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-bridge-port' and ../data-type != 'mgmt-l2fib-data-type-fxs'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType !=
'MGMT_L2FIB_DATA_TYPE_BRIDGE_PORT' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_FXS'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment2

              leaf xcon-name {
                type string {
                  length "0..72";
                }
                description "Xconnect name";
              }

              leaf bound {
                type boolean;
                description "Bound";
              }

              leaf switching-type {
                type Mgmt-l2fib-switching;
                description "SW Type";
              }
            }  // list l2fibx-con
          }  // container l2fibx-cons

          container l2fib-main-interfaces {
            description "Main Interface";
            list l2fib-main-interface {
              description
                "Main Interface Table";
              container l2fib-main-interface-hardware-egress-detail-info {
                description
                  "Main Interface hardware egress detail info";
                leaf main-interface {
                  type xr:Interface-name;
                  description
                    "Main Interface ID";
                }

                leaf main-if-type {
                  type uint8;
                  description
                    "Main Interface Type";
                }

                leaf virtual-if-name {
                  type string;
                  description
                    "Virtual Main IfName";
                }

                leaf mac {
                  type string;
                  description "MAC Address";
                }

                leaf esi-id {
                  type uint16;
                  description
                    "Ethernet segment ID";
                }

                leaf evpn-shg-local-label {
                  type uint32;
                  description
                    "EVPN split horizon group local label";
                }

                leaf evpn-rid {
                  type inet:ipv6-address;
                  description
                    "EVPN Router-ID";
                }

                leaf evpn-service-carving-mcast-mode {
                  type L2fib-evpn-sc-mcast-mode;
                  description
                    "EVPN Service Carving Mcast Mode";
                }

                leaf es-is-frr-protected {
                  type boolean;
                  description
                    "FRR Protection Configured";
                }

                leaf rx-adjacency-valid {
                  type boolean;
                  description
                    "RX Adjacency Is Valid";
                }

                leaf rx-adjacency-address {
                  type inet:ipv4-address;
                  description
                    "RX Adjacency Address";
                }

                list instance-id {
                  description "Instance IDs";
                  leaf entry {
                    type uint32;
                    description
                      "Instance IDs";
                  }
                }  // list instance-id

                list instances-state {
                  description
                    "State for each instance";
                  leaf entry {
                    type L2fib-main-if-instance-state;
                    description
                      "State for each instance";
                  }
                }  // list instances-state

                list instances-provisioned {
                  description
                    "Instances provisioned flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances provisioned flag";
                  }
                }  // list instances-provisioned

                list bridge-port-count-instance {
                  description
                    "Number of bridge ports per instance";
                  leaf entry {
                    type uint32;
                    description
                      "Number of bridge ports per instance";
                  }
                }  // list bridge-port-count-instance

                list ethernet-segment-identifier {
                  description
                    "Ethernet Segment Identifier";
                  leaf entry {
                    type uint8;
                    description
                      "Ethernet Segment Identifier";
                  }
                }  // list ethernet-segment-identifier

                list evpn-shg-remote-info {
                  description
                    "EVPN split horizon group remote info";
                  container remote-split-horizon-group-label {
                    description
                      "Remote split horizon group label";
                    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";
                    }
                  }  // container remote-split-horizon-group-label
                }  // list evpn-shg-remote-info

                list es-next-hop {
                  description "ES NextHops";
                  leaf address {
                    type inet:ipv6-address;
                    description "IP Address";
                  }
                }  // list es-next-hop

                list instances-frr {
                  description
                    "Instances FRR active flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances FRR active flag";
                  }
                }  // list instances-frr

                list instances-protecion-enabled {
                  description
                    "Instances prot-on flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances prot-on flag";
                  }
                }  // list instances-protecion-enabled
              }  // container l2fib-main-interface-hardware-egress-detail-info

              container l2fib-main-interface-hardware-egress-info {
                description
                  "Main Interface hardware egress info";
                leaf main-interface {
                  type xr:Interface-name;
                  description
                    "Main Interface ID";
                }

                leaf main-if-type {
                  type uint8;
                  description
                    "Main Interface Type";
                }

                leaf virtual-if-name {
                  type string;
                  description
                    "Virtual Main IfName";
                }

                list instance-id {
                  description "Instance IDs";
                  leaf entry {
                    type uint32;
                    description
                      "Instance IDs";
                  }
                }  // list instance-id

                list instances-state {
                  description
                    "State for each instance";
                  leaf entry {
                    type L2fib-main-if-instance-state;
                    description
                      "State for each instance";
                  }
                }  // list instances-state

                list instances-provisioned {
                  description
                    "Instances provisioned flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances provisioned flag";
                  }
                }  // list instances-provisioned

                list instances-frr {
                  description
                    "Instances FRR active flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances FRR active flag";
                  }
                }  // list instances-frr

                list instances-protecion-enabled {
                  description
                    "Instances prot-on flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances prot-on flag";
                  }
                }  // list instances-protecion-enabled
              }  // container l2fib-main-interface-hardware-egress-info

              container l2fib-main-interface-instances {
                description
                  "Main Interface Instance table";
                list l2fib-main-interface-instance {
                  key "instance";
                  description
                    "Main Interface Instance";
                  container l2fib-main-interface-instance-detail-info {
                    description
                      "Main Interface Instance detail info";
                    leaf main-interface {
                      type xr:Interface-name;
                      description
                        "Main interface ID";
                    }

                    leaf main-if-type {
                      type uint8;
                      description
                        "Main Interface Type";
                    }

                    leaf virtual-if-name {
                      type string;
                      description
                        "Virtual Main IfName";
                    }

                    leaf instance {
                      type uint32;
                      description
                        "Interface instance";
                    }

                    leaf state {
                      type L2fib-main-if-instance-state;
                      description
                        "Instance state";
                    }

                    leaf bridge-port-count {
                      type uint32;
                      description
                        "Number of bridge ports";
                    }

                    leaf instance-provisioned {
                      type boolean;
                      description
                        "Instances provisioned flag";
                    }
                  }  // container l2fib-main-interface-instance-detail-info

                  container l2fib-main-interface-instance-bridge-port-details {
                    description
                      "Main Interface Instance Bridge Port detail
                     table";
                    list l2fib-main-interface-instance-bridge-port-detail {
                      key "xcid";
                      description
                        "Main Interface Bridge Port detail info";
                      leaf xcid {
                        type xr:Hex-integer;
                        description
                          "Bridge Port";
                      }

                      container oper {
                        description
                          "Operational information";
                        container operational-information {
                          description
                            "L2 operational information";
                          leaf mtu {
                            type uint32;
                            description
                              "MTU";
                          }

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

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

                          leaf number-of-macs {
                            type uint32;
                            description
                              "numberOfMacs";
                          }

                          leaf admin-disabled {
                            type boolean;
                            description
                              "Is administratively disabled";
                          }

                          leaf flooding-disabled {
                            type boolean;
                            description
                              "Is flooding disabled";
                          }

                          leaf flood-unknown-unicast-enabled {
                            type boolean;
                            description
                              "Is flooding unknown unicast disabled";
                          }

                          leaf mac-limit-action {
                            type Mgmt-l2fib-mac-limit-action;
                            description
                              "MAC limit action";
                          }

                          leaf mac-limit-threshold {
                            type uint32;
                            units
                              "percentage";
                            description
                              "MAC limit percentage recovery threshold";
                          }

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

                          leaf mac-port-down-flush-disabled {
                            type boolean;
                            description
                              "Is MAC port down flush disabled";
                          }

                          leaf mac-limit-notification-type {
                            type Mgmt-l2fib-mac-limit-notify;
                            description
                              "MAC limit notification";
                          }

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

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

                          leaf mac-secure-action {
                            type Mgmt-l2fib-mac-sec-action;
                            description
                              "MAC secure action";
                          }

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

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

                          leaf mac-aging-type {
                            type Mgmt-l2fib-mac-aging;
                            description
                              "MAC aging type";
                          }

                          leaf l2mc-src-traffic-enabled {
                            type uint32;
                            description
                              "L2MC Source Traffic Enabled";
                          }

                          leaf storm-control-unicast-enabled {
                            type boolean;
                            description
                              "Is unicast storm control enabled";
                          }

                          leaf storm-control-broadcast-enabled {
                            type boolean;
                            description
                              "Is broadcast storm control enabled";
                          }

                          leaf storm-control-multicast-enabled {
                            type boolean;
                            description
                              "Is multicast storm control enabled";
                          }

                          leaf storm-control-unicast-rate-unit {
                            type L2fib-storm-control-rate-unit;
                            description
                              "Storm control unicast rate unit";
                          }

                          leaf storm-control-broadcast-rate-unit {
                            type L2fib-storm-control-rate-unit;
                            description
                              "Storm control broadcast rate unit";
                          }

                          leaf storm-control-multicast-rate-unit {
                            type L2fib-storm-control-rate-unit;
                            description
                              "Storm control multicast rate unit";
                          }

                          leaf dhcp-enabled {
                            type boolean;
                            description
                              "Is DHCP snooping enabled";
                          }

                          leaf dhcp-trusted {
                            type boolean;
                            description
                              "Is DHCP trusted";
                          }

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

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

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

                          leaf is-dai-addr-validation-destination-mac-enabled {
                            type boolean;
                            description
                              "Is DAI Destination MAC Validation enabled";
                          }

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

                          leaf is-ipsg-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-vpls-flood-optimization-enabled {
                            type boolean;
                            description
                              "Is MMRP  Flood Optimization Enabled";
                          }

                          leaf igmp-snoop-enabled {
                            type boolean;
                            description
                              "Is IGMP snooping enabled";
                          }

                          leaf igmp-snoop-profile-enabled {
                            type boolean;
                            description
                              "Is IGMP snooping profile enabled";
                          }

                          leaf igmp-flood-forward-enabled {
                            type boolean;
                            description
                              "Is IGMP flood forwarding enabled";
                          }

                          leaf igmp-mroute-port-enabled {
                            type boolean;
                            description
                              "Is mrouter port";
                          }

                          leaf igmp-route-guard-enabled {
                            type boolean;
                            description
                              "Is router gurad enabled";
                          }

                          leaf mld-snoop-enabled {
                            type boolean;
                            description
                              "Is MLD snooping enabled";
                          }

                          leaf mld-snoop-profile-enabled {
                            type boolean;
                            description
                              "Is MLD snooping profile enabled";
                          }

                          leaf mld-flood-forward-enabled {
                            type boolean;
                            description
                              "Is MLD flood forwarding enabled";
                          }

                          leaf mld-mroute-port-enabled {
                            type boolean;
                            description
                              "Is mrouter port";
                          }

                          leaf mld-route-guard-enabled {
                            type boolean;
                            description
                              "Is router gurad enabled";
                          }

                          leaf stp-participating {
                            type boolean;
                            description
                              "Is Spanning Tree Protocol participating";
                          }

                          leaf bvi-configured {
                            type boolean;
                            description
                              "Is BVI Interface configured";
                          }

                          leaf is-bvi-up {
                            type boolean;
                            description
                              "Is BVI state UP";
                          }

                          leaf is-vni-enabled {
                            type boolean;
                            description
                              "Is VNI enabled";
                          }

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

                          leaf unknown-unicast-flooding-disabled {
                            type boolean;
                            description
                              "Unknown Unicast Flooding is disabled";
                          }

                          leaf is-pbbevpn-enabled {
                            type boolean;
                            description
                              "Is PBBEVPN enabled";
                          }

                          leaf is-swmac-learning {
                            type boolean;
                            description
                              "Is SW MAC learning enabled";
                          }

                          leaf is-evpn-flow-label {
                            type boolean;
                            description
                              "Is EVPN Flow Label enabled";
                          }

                          leaf is-evpn-cw-disable {
                            type boolean;
                            description
                              "Is EVPN CW disabled";
                          }

                          leaf msti {
                            type uint32;
                            description
                              "Multi-spanning tree instance";
                          }

                          leaf is-p2mp-pw-enabled {
                            type boolean;
                            description
                              "Is P2MP PW enabled";
                          }

                          leaf is-igmp-snoop-enabled {
                            type boolean;
                            description
                              "Is IGMP Snooping admin enabled";
                          }

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

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

                          leaf is-ves {
                            type boolean;
                            description
                              "Is Virtual Ethernet Segement feature enabled";
                          }

                          list feature {
                            description
                              "Feature information";
                            container dhcp {
                              when
                                "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                                description
                                  "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                              }
                              description
                                "dhcp";
                              leaf profile-name {
                                type string;
                                description
                                  "Feature profile name";
                              }
                            }  // container dhcp

                            container igmp {
                              when
                                "../feature-type = 'l2fib-feature-igmp-snooping'" {
                                description
                                  "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                              }
                              description
                                "igmp";
                              leaf profile-name {
                                type string;
                                description
                                  "Feature profile name";
                              }
                            }  // container igmp

                            container mld {
                              when
                                "../feature-type = 'l2fib-feature-mld-snooping'" {
                                description
                                  "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                              }
                              description
                                "mld";
                              leaf profile-name {
                                type string;
                                description
                                  "Feature profile name";
                              }
                            }  // container mld

                            leaf feature-type {
                              type L2fib-feature;
                              description
                                "feature type";
                            }
                          }  // list feature
                        }  // container operational-information

                        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 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 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";
                        }
                      }  // container oper

                      leaf bridge-port-id {
                        type xr:Interface-name;
                        description
                          "Bridge Port ID";
                      }

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

                      leaf state {
                        type L2fib-main-if-instance-state;
                        description
                          "Instance state";
                      }

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

                      leaf main-if-type {
                        type uint8;
                        description
                          "Main Interface Type";
                      }

                      leaf virtual-if-name {
                        type string;
                        description
                          "Virtual Main IfName";
                      }

                      leaf bp-type {
                        type uint8;
                        description
                          "Bridge Port Type";
                      }
                    }  // list l2fib-main-interface-instance-bridge-port-detail
                  }  // container l2fib-main-interface-instance-bridge-port-details

                  container l2fib-main-interface-instance-info {
                    description
                      "Main Interface Instance info";
                    leaf main-interface {
                      type xr:Interface-name;
                      description
                        "Main interface ID";
                    }

                    leaf main-if-type {
                      type uint8;
                      description
                        "Main Interface Type";
                    }

                    leaf virtual-if-name {
                      type string;
                      description
                        "Virtual Main IfName";
                    }

                    leaf instance {
                      type uint32;
                      description
                        "Interface instance";
                    }

                    leaf state {
                      type L2fib-main-if-instance-state;
                      description
                        "Instance state";
                    }

                    leaf bridge-port-count {
                      type uint32;
                      description
                        "Number of bridge ports";
                    }

                    leaf instance-provisioned {
                      type boolean;
                      description
                        "Instances provisioned flag";
                    }
                  }  // container l2fib-main-interface-instance-info

                  container l2fib-main-interface-instance-hardware-ingress-detail-info {
                    description
                      "Main Interface Instance hardware ingress
                     detail info";
                    leaf main-interface {
                      type xr:Interface-name;
                      description
                        "Main interface ID";
                    }

                    leaf main-if-type {
                      type uint8;
                      description
                        "Main Interface Type";
                    }

                    leaf virtual-if-name {
                      type string;
                      description
                        "Virtual Main IfName";
                    }

                    leaf instance {
                      type uint32;
                      description
                        "Interface instance";
                    }

                    leaf state {
                      type L2fib-main-if-instance-state;
                      description
                        "Instance state";
                    }

                    leaf bridge-port-count {
                      type uint32;
                      description
                        "Number of bridge ports";
                    }

                    leaf instance-provisioned {
                      type boolean;
                      description
                        "Instances provisioned flag";
                    }
                  }  // container l2fib-main-interface-instance-hardware-ingress-detail-info

                  container l2fib-main-interface-instance-hardware-egress-info {
                    description
                      "Main Interface Instance hardware egress
                     info";
                    leaf main-interface {
                      type xr:Interface-name;
                      description
                        "Main interface ID";
                    }

                    leaf main-if-type {
                      type uint8;
                      description
                        "Main Interface Type";
                    }

                    leaf virtual-if-name {
                      type string;
                      description
                        "Virtual Main IfName";
                    }

                    leaf instance {
                      type uint32;
                      description
                        "Interface instance";
                    }

                    leaf state {
                      type L2fib-main-if-instance-state;
                      description
                        "Instance state";
                    }

                    leaf bridge-port-count {
                      type uint32;
                      description
                        "Number of bridge ports";
                    }

                    leaf instance-provisioned {
                      type boolean;
                      description
                        "Instances provisioned flag";
                    }
                  }  // container l2fib-main-interface-instance-hardware-egress-info

                  container l2fib-main-interface-instance-hardware-ingress-info {
                    description
                      "Main Interface Instance hardware ingress
                     info";
                    leaf main-interface {
                      type xr:Interface-name;
                      description
                        "Main interface ID";
                    }

                    leaf main-if-type {
                      type uint8;
                      description
                        "Main Interface Type";
                    }

                    leaf virtual-if-name {
                      type string;
                      description
                        "Virtual Main IfName";
                    }

                    leaf instance {
                      type uint32;
                      description
                        "Interface instance";
                    }

                    leaf state {
                      type L2fib-main-if-instance-state;
                      description
                        "Instance state";
                    }

                    leaf bridge-port-count {
                      type uint32;
                      description
                        "Number of bridge ports";
                    }

                    leaf instance-provisioned {
                      type boolean;
                      description
                        "Instances provisioned flag";
                    }
                  }  // container l2fib-main-interface-instance-hardware-ingress-info

                  container l2fib-main-interface-instance-bridge-ports {
                    description
                      "Main Interface Instance Bridge Port table";
                    list l2fib-main-interface-instance-bridge-port {
                      key "xcid";
                      description
                        "Main Interface Bridge Port info";
                      leaf xcid {
                        type xr:Hex-integer;
                        description
                          "Bridge Port";
                      }

                      leaf bridge-port-id {
                        type xr:Interface-name;
                        description
                          "Bridge Port ID";
                      }

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

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

                      leaf main-if-type {
                        type uint8;
                        description
                          "Main Interface Type";
                      }

                      leaf virtual-if-name {
                        type string;
                        description
                          "Virtual Main IfName";
                      }

                      leaf bp-type {
                        type uint8;
                        description
                          "Bridge Port Type";
                      }
                    }  // list l2fib-main-interface-instance-bridge-port
                  }  // container l2fib-main-interface-instance-bridge-ports

                  container l2fib-main-interface-instance-hardware-egress-detail-info {
                    description
                      "Main Interface Instance hardware egress
                     detail info";
                    leaf main-interface {
                      type xr:Interface-name;
                      description
                        "Main interface ID";
                    }

                    leaf main-if-type {
                      type uint8;
                      description
                        "Main Interface Type";
                    }

                    leaf virtual-if-name {
                      type string;
                      description
                        "Virtual Main IfName";
                    }

                    leaf instance {
                      type uint32;
                      description
                        "Interface instance";
                    }

                    leaf state {
                      type L2fib-main-if-instance-state;
                      description
                        "Instance state";
                    }

                    leaf bridge-port-count {
                      type uint32;
                      description
                        "Number of bridge ports";
                    }

                    leaf instance-provisioned {
                      type boolean;
                      description
                        "Instances provisioned flag";
                    }
                  }  // container l2fib-main-interface-instance-hardware-egress-detail-info

                  leaf instance {
                    type Msti-range;
                    description "Instance";
                  }
                }  // list l2fib-main-interface-instance
              }  // container l2fib-main-interface-instances

              container l2fib-main-interface-info {
                description
                  "Main Interface info";
                leaf main-interface {
                  type xr:Interface-name;
                  description
                    "Main Interface ID";
                }

                leaf main-if-type {
                  type uint8;
                  description
                    "Main Interface Type";
                }

                leaf virtual-if-name {
                  type string;
                  description
                    "Virtual Main IfName";
                }

                list instance-id {
                  description "Instance IDs";
                  leaf entry {
                    type uint32;
                    description
                      "Instance IDs";
                  }
                }  // list instance-id

                list instances-state {
                  description
                    "State for each instance";
                  leaf entry {
                    type L2fib-main-if-instance-state;
                    description
                      "State for each instance";
                  }
                }  // list instances-state

                list instances-provisioned {
                  description
                    "Instances provisioned flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances provisioned flag";
                  }
                }  // list instances-provisioned

                list instances-frr {
                  description
                    "Instances FRR active flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances FRR active flag";
                  }
                }  // list instances-frr

                list instances-protecion-enabled {
                  description
                    "Instances prot-on flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances prot-on flag";
                  }
                }  // list instances-protecion-enabled
              }  // container l2fib-main-interface-info

              container l2fib-main-interface-detail-info {
                description
                  "Main Interface detail info";
                leaf main-interface {
                  type xr:Interface-name;
                  description
                    "Main Interface ID";
                }

                leaf main-if-type {
                  type uint8;
                  description
                    "Main Interface Type";
                }

                leaf virtual-if-name {
                  type string;
                  description
                    "Virtual Main IfName";
                }

                leaf mac {
                  type string;
                  description "MAC Address";
                }

                leaf esi-id {
                  type uint16;
                  description
                    "Ethernet segment ID";
                }

                leaf evpn-shg-local-label {
                  type uint32;
                  description
                    "EVPN split horizon group local label";
                }

                leaf evpn-rid {
                  type inet:ipv6-address;
                  description
                    "EVPN Router-ID";
                }

                leaf evpn-service-carving-mcast-mode {
                  type L2fib-evpn-sc-mcast-mode;
                  description
                    "EVPN Service Carving Mcast Mode";
                }

                leaf es-is-frr-protected {
                  type boolean;
                  description
                    "FRR Protection Configured";
                }

                leaf rx-adjacency-valid {
                  type boolean;
                  description
                    "RX Adjacency Is Valid";
                }

                leaf rx-adjacency-address {
                  type inet:ipv4-address;
                  description
                    "RX Adjacency Address";
                }

                list instance-id {
                  description "Instance IDs";
                  leaf entry {
                    type uint32;
                    description
                      "Instance IDs";
                  }
                }  // list instance-id

                list instances-state {
                  description
                    "State for each instance";
                  leaf entry {
                    type L2fib-main-if-instance-state;
                    description
                      "State for each instance";
                  }
                }  // list instances-state

                list instances-provisioned {
                  description
                    "Instances provisioned flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances provisioned flag";
                  }
                }  // list instances-provisioned

                list bridge-port-count-instance {
                  description
                    "Number of bridge ports per instance";
                  leaf entry {
                    type uint32;
                    description
                      "Number of bridge ports per instance";
                  }
                }  // list bridge-port-count-instance

                list ethernet-segment-identifier {
                  description
                    "Ethernet Segment Identifier";
                  leaf entry {
                    type uint8;
                    description
                      "Ethernet Segment Identifier";
                  }
                }  // list ethernet-segment-identifier

                list evpn-shg-remote-info {
                  description
                    "EVPN split horizon group remote info";
                  container remote-split-horizon-group-label {
                    description
                      "Remote split horizon group label";
                    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";
                    }
                  }  // container remote-split-horizon-group-label
                }  // list evpn-shg-remote-info

                list es-next-hop {
                  description "ES NextHops";
                  leaf address {
                    type inet:ipv6-address;
                    description "IP Address";
                  }
                }  // list es-next-hop

                list instances-frr {
                  description
                    "Instances FRR active flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances FRR active flag";
                  }
                }  // list instances-frr

                list instances-protecion-enabled {
                  description
                    "Instances prot-on flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances prot-on flag";
                  }
                }  // list instances-protecion-enabled
              }  // container l2fib-main-interface-detail-info

              container l2fib-main-interface-hardware-ingress-detail-info {
                description
                  "Main Interface hardware ingress detail info";
                leaf main-interface {
                  type xr:Interface-name;
                  description
                    "Main Interface ID";
                }

                leaf main-if-type {
                  type uint8;
                  description
                    "Main Interface Type";
                }

                leaf virtual-if-name {
                  type string;
                  description
                    "Virtual Main IfName";
                }

                leaf mac {
                  type string;
                  description "MAC Address";
                }

                leaf esi-id {
                  type uint16;
                  description
                    "Ethernet segment ID";
                }

                leaf evpn-shg-local-label {
                  type uint32;
                  description
                    "EVPN split horizon group local label";
                }

                leaf evpn-rid {
                  type inet:ipv6-address;
                  description
                    "EVPN Router-ID";
                }

                leaf evpn-service-carving-mcast-mode {
                  type L2fib-evpn-sc-mcast-mode;
                  description
                    "EVPN Service Carving Mcast Mode";
                }

                leaf es-is-frr-protected {
                  type boolean;
                  description
                    "FRR Protection Configured";
                }

                leaf rx-adjacency-valid {
                  type boolean;
                  description
                    "RX Adjacency Is Valid";
                }

                leaf rx-adjacency-address {
                  type inet:ipv4-address;
                  description
                    "RX Adjacency Address";
                }

                list instance-id {
                  description "Instance IDs";
                  leaf entry {
                    type uint32;
                    description
                      "Instance IDs";
                  }
                }  // list instance-id

                list instances-state {
                  description
                    "State for each instance";
                  leaf entry {
                    type L2fib-main-if-instance-state;
                    description
                      "State for each instance";
                  }
                }  // list instances-state

                list instances-provisioned {
                  description
                    "Instances provisioned flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances provisioned flag";
                  }
                }  // list instances-provisioned

                list bridge-port-count-instance {
                  description
                    "Number of bridge ports per instance";
                  leaf entry {
                    type uint32;
                    description
                      "Number of bridge ports per instance";
                  }
                }  // list bridge-port-count-instance

                list ethernet-segment-identifier {
                  description
                    "Ethernet Segment Identifier";
                  leaf entry {
                    type uint8;
                    description
                      "Ethernet Segment Identifier";
                  }
                }  // list ethernet-segment-identifier

                list evpn-shg-remote-info {
                  description
                    "EVPN split horizon group remote info";
                  container remote-split-horizon-group-label {
                    description
                      "Remote split horizon group label";
                    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";
                    }
                  }  // container remote-split-horizon-group-label
                }  // list evpn-shg-remote-info

                list es-next-hop {
                  description "ES NextHops";
                  leaf address {
                    type inet:ipv6-address;
                    description "IP Address";
                  }
                }  // list es-next-hop

                list instances-frr {
                  description
                    "Instances FRR active flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances FRR active flag";
                  }
                }  // list instances-frr

                list instances-protecion-enabled {
                  description
                    "Instances prot-on flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances prot-on flag";
                  }
                }  // list instances-protecion-enabled
              }  // container l2fib-main-interface-hardware-ingress-detail-info

              container l2fib-main-interface-hardware-ingress-info {
                description
                  "Main Interface hardware ingress info";
                leaf main-interface {
                  type xr:Interface-name;
                  description
                    "Main Interface ID";
                }

                leaf main-if-type {
                  type uint8;
                  description
                    "Main Interface Type";
                }

                leaf virtual-if-name {
                  type string;
                  description
                    "Virtual Main IfName";
                }

                list instance-id {
                  description "Instance IDs";
                  leaf entry {
                    type uint32;
                    description
                      "Instance IDs";
                  }
                }  // list instance-id

                list instances-state {
                  description
                    "State for each instance";
                  leaf entry {
                    type L2fib-main-if-instance-state;
                    description
                      "State for each instance";
                  }
                }  // list instances-state

                list instances-provisioned {
                  description
                    "Instances provisioned flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances provisioned flag";
                  }
                }  // list instances-provisioned

                list instances-frr {
                  description
                    "Instances FRR active flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances FRR active flag";
                  }
                }  // list instances-frr

                list instances-protecion-enabled {
                  description
                    "Instances prot-on flag";
                  leaf entry {
                    type boolean;
                    description
                      "Instances prot-on flag";
                  }
                }  // list instances-protecion-enabled
              }  // container l2fib-main-interface-hardware-ingress-info

              leaf main-interface-id {
                type Main-interface-id-range;
                description
                  "Main interface id";
              }

              leaf main-interface-type {
                type Evpn-main-interface;
                description
                  "Main interface type";
              }
            }  // list l2fib-main-interface
          }  // container l2fib-main-interfaces

          container l2fib-message-hardware-summary {
            description
              "L2FIB Message Summary information from
             hardware";
          }  // container l2fib-message-hardware-summary

          container l2fib-mstp-details {
            description "MSTP Detail Table";
            list l2fib-mstp-detail {
              description
                "MSTP Detail information";
              leaf parent-interface {
                type xr:Interface-name;
                description
                  "Parent interface context";
              }

              leaf main-interface-type {
                type Evpn-main-interface;
                description
                  "Main port interface type";
              }

              leaf msti {
                type Msti-range;
                description "MSTI context";
              }

              leaf parent-interface-xr {
                type xr:Interface-name;
                description "main port ID";
              }

              leaf msti-xr {
                type uint32;
                description
                  "multi-spanning tree instance configured value";
              }

              leaf internal-msti {
                type uint32;
                description
                  "multi-spanning tree instance internal value";
              }

              leaf state {
                type uint32;
                description "MSTI state";
              }

              leaf learn-key {
                type uint8;
                description "Learn Key";
              }

              leaf-list bridge-port-array {
                type xr:Interface-name;
                description "Bridge port";
              }
            }  // list l2fib-mstp-detail
          }  // container l2fib-mstp-details

          container l2fib-l2tp {
            description "L2TP";
            container l2tpv3-sessions {
              description
                "L2TPV3 Session table";
              list l2tpv3-session {
                key "session-id";
                description "L2TPV3 Session";
                leaf session-id {
                  type L2tpv3-session-id-range;
                  description "SessionID";
                }

                leaf session-id-xr {
                  type uint32;
                  description
                    "Local Session Id";
                }

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

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

                leaf source-address {
                  type inet:ipv4-address;
                  description
                    "Source/Local IP address of the tunnel";
                }

                leaf bound {
                  type boolean;
                  description "Bind status";
                }

                leaf tunnel-id-xr {
                  type uint32;
                  description
                    "Tunnel ID, l2tpv2";
                }

                leaf ipv4-table-id {
                  type uint32;
                  description
                    "IPv4 Table ID";
                }

                leaf ipv6-table-id {
                  type uint32;
                  description
                    "IPv6 Table ID";
                }

                leaf nhop-ip-addr {
                  type inet:ipv4-address;
                  description
                    "NHOP IP Address of the tunnel";
                }

                leaf session-type {
                  type L2fib-l2tp-session;
                  description
                    "L2tp or L2tpv2 session";
                }
              }  // list l2tpv3-session
            }  // container l2tpv3-sessions

            container l2tpv2-sessions {
              description
                "L2TPV2 Session table";
              list l2tpv2-session {
                description "L2TPV2 Session";
                leaf session-id {
                  type L2tpv2-session-id-range;
                  description "SessionID";
                }

                leaf tunnel-id {
                  type Tunnel-id-range;
                  description "TunnelID";
                }

                leaf session-id-xr {
                  type uint32;
                  description
                    "Local Session Id";
                }

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

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

                leaf source-address {
                  type inet:ipv4-address;
                  description
                    "Source/Local IP address of the tunnel";
                }

                leaf bound {
                  type boolean;
                  description "Bind status";
                }

                leaf tunnel-id-xr {
                  type uint32;
                  description
                    "Tunnel ID, l2tpv2";
                }

                leaf ipv4-table-id {
                  type uint32;
                  description
                    "IPv4 Table ID";
                }

                leaf ipv6-table-id {
                  type uint32;
                  description
                    "IPv6 Table ID";
                }

                leaf nhop-ip-addr {
                  type inet:ipv4-address;
                  description
                    "NHOP IP Address of the tunnel";
                }

                leaf session-type {
                  type L2fib-l2tp-session;
                  description
                    "L2tp or L2tpv2 session";
                }
              }  // list l2tpv2-session
            }  // container l2tpv2-sessions
          }  // container l2fib-l2tp

          container l2fib-g8032 {
            description "G8032 information";
            container l2fib-g8032-rings {
              description "G8032 Ring table";
              list l2fib-g8032-ring {
                key "ring-name";
                description "G8032 Ring";
                container l2fib-g8032-ring-detail {
                  description
                    "G8032 Ring detailed information";
                  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-open-ring {
                    type boolean;
                    description "Open Ring";
                  }
                }  // container l2fib-g8032-ring-detail

                container l2fib-g8032-ring-summary {
                  description
                    "G8032 Ring summary information";
                  leaf ring-name {
                    type string;
                    description
                      "Name of the ring";
                  }

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

                  leaf port1 {
                    type string;
                    description "Port 1";
                  }
                }  // container l2fib-g8032-ring-summary

                container l2fib-g8032-ring-instance-summaries {
                  description
                    "G8032 Ring Instance summary table";
                  list l2fib-g8032-ring-instance-summary {
                    key "instance";
                    description
                      "G8032 Ring Instance summary information";
                    leaf instance {
                      type G8032-ring-instance-range;
                      description "Instance";
                    }

                    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";
                    }
                  }  // list l2fib-g8032-ring-instance-summary
                }  // container l2fib-g8032-ring-instance-summaries

                container l2fib-g8032-ring-instance-details {
                  description
                    "G8032 Ring Instance detail table";
                  list l2fib-g8032-ring-instance-detail {
                    key "instance";
                    description
                      "G8032 Ring Instance detailed information";
                    leaf instance {
                      type G8032-ring-instance-range;
                      description "Instance";
                    }

                    leaf ring-instance {
                      type uint32;
                      description
                        "Ring instance number";
                    }

                    leaf vlan-ids {
                      type string;
                      description "Vlan Ids";
                    }

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

                    leaf rpl {
                      type L2fib-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 aps-port-status0 {
                      type L2fib-g8032-aps-port-status;
                      description
                        "Status of Port 0";
                    }

                    leaf aps-port-status1 {
                      type L2fib-g8032-aps-port-status;
                      description
                        "Status of Port 1";
                    }

                    leaf aps-channel-level {
                      type uint32;
                      description
                        "APS channel level";
                    }
                  }  // list l2fib-g8032-ring-instance-detail
                }  // container l2fib-g8032-ring-instance-details

                leaf ring-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description "Ring Name";
                }
              }  // list l2fib-g8032-ring
            }  // container l2fib-g8032-rings
          }  // container l2fib-g8032

          container l2fib-bridge-ports {
            description
              "Bridge Port forwarding detail";
            list l2fib-bridge-port {
              description
                "Specify Bridge Domain Name and XC ID";
              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Group Name";
              }

              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf xc-uint-id {
                type xr:Hex-integer;
                description "XC ID";
              }

              container segment {
                description "Segment";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  container fxc-next-hop {
                    description
                      "Flexible XConnect Service Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container fxc-next-hop

                  container ac-backup {
                    description
                      "AC Backup information";
                    container next-hop {
                      description "Next Hop";
                      leaf type {
                        type L2fib-nhop;
                        description
                          "Nexthop Type";
                      }

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "NHOP Address";
                      }

                      leaf next-hop-address-v6 {
                        type inet:ipv6-address;
                        description
                          "NHOP Address V6";
                      }

                      leaf next-hop-te-interface-name {
                        type xr:Interface-name;
                        description
                          "NHOP (SR-)TE Interface";
                      }

                      leaf next-hop-lsm-id {
                        type uint32;
                        description
                          "NHOP LSM ID";
                      }

                      leaf next-hop-sr-te-bsid {
                        type uint32;
                        description
                          "NHOP SR-TE Binding Label (BSID)";
                      }

                      leaf next-hop-internal-label {
                        type uint32;
                        description
                          "NHOP Internal Label";
                      }

                      leaf next-hop-internal-id {
                        type uint32;
                        description
                          "NHOP Internal ID";
                      }

                      leaf pin-down-interface-name {
                        type xr:Interface-name;
                        description
                          "Pin-down Interface Name";
                      }

                      leaf ecd-platform-data-valid {
                        type boolean;
                        description
                          "Is Platform ECD Data Valid";
                      }

                      leaf ecd-platform-data-length {
                        type uint32;
                        description
                          "Platform ECD Data Length";
                      }

                      leaf children-count {
                        type uint32;
                        description
                          "Children Count";
                      }

                      leaf children-evpn-ole-count {
                        type uint32;
                        description
                          "Children EVPN OLE Count";
                      }

                      leaf children-mac-count {
                        type uint32;
                        description
                          "Children MAC Count";
                      }

                      leaf children-pwhe-mp-count {
                        type uint32;
                        description
                          "Children PW-HE MainPort Count";
                      }

                      leaf children-ac-backup-count {
                        type uint32;
                        description
                          "Children AC-BACKUP Count";
                      }

                      leaf children-pw-ipv4-interface-list-count {
                        type uint32;
                        description
                          "Children PW IP-IFL Count";
                      }

                      leaf children-pw-te-tunnel-interface-list-count {
                        type uint32;
                        description
                          "Children PW IFH-IFL Count";
                      }
                    }  // container next-hop

                    leaf next-hop-valid {
                      type boolean;
                      description
                        "Is Next Hop Valid";
                    }

                    leaf vc-label {
                      type uint32;
                      description
                        "Virtual Circuit Label";
                    }
                  }  // container ac-backup

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

                  leaf sub-interface-handle {
                    type xr:Interface-name;
                    description
                      "Sub Interface Handle";
                  }

                  leaf attachment-circuit-id {
                    type uint32;
                    description
                      "Attachment Circuit ID";
                  }

                  leaf attachment-circuit-mtu {
                    type uint16;
                    description
                      "MTU of Attachment Circuit";
                  }

                  leaf actype {
                    type uint8;
                    description
                      "Attachment Circuit Type";
                  }

                  leaf inter-working-mode {
                    type uint8;
                    description
                      "Interworking Mode";
                  }

                  leaf adjacency-valid {
                    type boolean;
                    description
                      "Adjacency Is Valid";
                  }

                  leaf adjacency-address {
                    type inet:ipv4-address;
                    description
                      "Adjacency Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf ip-inter-working-mac {
                    type string;
                    description
                      "IP Interworking MAC";
                  }

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

                  leaf redundancy-object-id {
                    type uint64;
                    description
                      "ICCP Redundancy Object ID";
                  }

                  leaf evpn-internal-label {
                    type uint32;
                    description
                      "EVPN Internal Label";
                  }

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

                  leaf fxc-next-hop-valid {
                    type boolean;
                    description
                      "Is Flexible XConnect Service Next Hop Valid";
                  }

                  leaf rewrittenvlan-id-count {
                    type uint8;
                    description
                      "Number of rewritten VLAN IDs";
                  }

                  leaf rewritten-first-vlan-id {
                    type uint16;
                    description
                      "First rewritten VLAN ID";
                  }

                  leaf rewritten-second-vlan-id {
                    type uint16;
                    description
                      "Second rewritten VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  container pbb-union {
                    description
                      "Union of Edge and Core";
                    container edge {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-edge'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_EDGE'";
                      }
                      description "edge";
                      leaf mac-configured {
                        type boolean;
                        description
                          "Configured MAC";
                      }

                      leaf mac {
                        type yang:mac-address;
                        description
                          "unknown unicast bmac";
                      }
                    }  // container edge

                    container core {
                      when
                        "../pbb-type = 'mgmt-l2fib-bridge-type-pbb-core'" {
                        description
                          "../PbbType = 'MGMT_L2FIB_BRIDGE_TYPE_PBB_CORE'";
                      }
                      description "core";
                      leaf vlan-id {
                        type uint32;
                        description
                          "vlan id";
                      }
                    }  // container core

                    leaf pbb-type {
                      type Mgmt-l2fib-bridge;
                      description "PbbType";
                    }
                  }  // container pbb-union

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf core-pbb-evpn-enabled {
                    type boolean;
                    description
                      "Core PBB-EVPN enabled";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf srcip {
                    type inet:ipv4-address;
                    description
                      "VNI Src IPv4 Address";
                  }

                  leaf mcastip {
                    type inet:ipv4-address;
                    description
                      "VNI Mcast IP Address";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

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

                  leaf encap {
                    type uint32;
                    description
                      "Encap type of VNI";
                  }

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

                  leaf source-vtep-if {
                    type xr:Interface-name;
                    description
                      "Source IF Handle";
                  }

                  leaf any-cast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast VTEP IP";
                  }

                  leaf anycast-mcast-ip {
                    type inet:ipv4-address;
                    description
                      "Anycast Multicast IP";
                  }

                  leaf ingress-replication {
                    type boolean;
                    description
                      "Ingress Replication supported on VNI";
                  }

                  leaf vx-lan-mode {
                    type uint32;
                    description "Vxlan mode";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf evi {
                    type uint32;
                    description "EVPN ID";
                  }

                  leaf forward-class {
                    type uint8;
                    description
                      "Forward Class";
                  }
                }  // container evpn

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "pw";
                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  container interface-list-next-hop {
                    description
                      "IFlist Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container interface-list-next-hop

                  container pseudo-wire-union {
                    description
                      "Union of MPLS or L2TP";
                    container mpls {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-atom'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_ATOM'";
                      }
                      description "mpls";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container mpls

                    container l2tp {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TP'";
                      }
                      description "l2tp";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

                      leaf sequence-number-expected {
                        type uint32;
                        description
                          "Number of sequence expected";
                      }
                    }  // container l2tp

                    container l2tpv2 {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tpv2'" {
                        description
                          "../DataType = 'MGMT_L2FIB_DATA_TYPE_L2TPV2'";
                      }
                      description "l2tpv2";
                      container local {
                        description
                          "Local session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TPv2 session ID";
                        }

                        leaf tunnel-id {
                          type uint32;
                          description
                            "L2TPv2 tunnel ID";
                        }
                      }  // container remote

                      leaf pw-flags {
                        type uint8;
                        description
                          "L2TPv2 PW flags";
                      }

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description
                          "TTL [Hops number]";
                      }

                      leaf path-mtu {
                        type uint16;
                        units "byte";
                        description
                          "Path MTU [Bytes]";
                      }

                      leaf protocol {
                        type uint16;
                        description
                          "Protocol [UDP RFC-768]";
                      }

                      leaf rem-udp-port {
                        type uint16;
                        description
                          "Remote UDP Port";
                      }

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

                      leaf next-hop-address {
                        type inet:ipv4-address;
                        description
                          "Next Hop Address";
                      }

                      leaf source-address {
                        type inet:ipv4-address;
                        description
                          "Source Address";
                      }
                    }  // container l2tpv2

                    container l2tp-ipv6-ts {
                      when
                        "../data-type = 'mgmt-l2fib-data-type-l2tp-ipv6-ts'" {
                        description
                          "../DataType =
'MGMT_L2FIB_DATA_TYPE_L2TP_IPV6_TS'";
                      }
                      description
                        "l2tp ipv6 ts";
                      container local {
                        description
                          "Local session info";
                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }

                        leaf secondary-cookie-size {
                          type uint8;
                          description
                            "Secondary Cookie size";
                        }

                        leaf secondary-cookie-low-value {
                          type uint32;
                          description
                            "Secondary Cookie low value";
                        }

                        leaf secondary-cookie-high-value {
                          type uint32;
                          description
                            "Secondary Cookie high value";
                        }

                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }
                      }  // container local

                      container remote {
                        description
                          "Remote session info";
                        leaf session-id {
                          type uint32;
                          description
                            "L2TP session ID";
                        }

                        leaf cookie-size {
                          type uint8;
                          description
                            "Cookie size";
                        }

                        leaf cookie-low-value {
                          type uint32;
                          description
                            "Cookie low value";
                        }

                        leaf cookie-high-value {
                          type uint32;
                          description
                            "Cookie high value";
                        }
                      }  // container remote

                      leaf tos-val {
                        type uint8;
                        description
                          "TOS val";
                      }

                      leaf ttl {
                        type uint8;
                        description "TTL";
                      }

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

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

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

                      leaf local-address {
                        type inet:ipv6-address;
                        description
                          "Local address";
                      }

                      leaf remote-address {
                        type inet:ipv6-address;
                        description
                          "Remote address";
                      }
                    }  // container l2tp-ipv6-ts

                    leaf data-type {
                      type Mgmt-l2fib-data;
                      description "DataType";
                    }
                  }  // container pseudo-wire-union

                  container backup-pseudo-wire {
                    description
                      "Backup Pseudowire";
                    container atom {
                      description "atom";
                      leaf pw-label {
                        type uint32;
                        description
                          "PW Label";
                      }

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

                      leaf pw-tunnel-interface {
                        type uint32;
                        description
                          "PW tunnel interface";
                      }

                      leaf pw-tunnel-bsid {
                        type uint32;
                        description
                          "PW SR-TE Binding Label (BSID)";
                      }

                      leaf pw-xcid {
                        type uint32;
                        description
                          "PW XCID";
                      }
                    }  // container atom

                    leaf backup-next-hop {
                      type inet:ipv4-address;
                      description
                        "Backup Next Hop";
                    }

                    leaf backup-pseudo-wire-id-type {
                      type L2fib-pw-id;
                      description
                        "Pseudowire ID type";
                    }

                    leaf backup-pseudo-wire-id {
                      type uint32;
                      description
                        "Backup Pseudowire ID";
                    }

                    leaf redundancy-role {
                      type L2fib-pw-redundancy-role;
                      description
                        "Redundancy Role";
                    }

                    leaf active {
                      type boolean;
                      description
                        "PW is active and forwarding";
                    }

                    leaf bound {
                      type boolean;
                      description "Bound";
                    }

                    leaf pw-flow-label-tx {
                      type boolean;
                      description
                        "Pseudowire flow label TX enabled";
                    }

                    leaf grouping-supported {
                      type boolean;
                      description
                        "Grouping supported";
                    }

                    leaf group-id {
                      type uint32;
                      description
                        "PW Group Id";
                    }

                    leaf group-state {
                      type L2fib-group-state;
                      description
                        "Group State";
                    }
                  }  // container backup-pseudo-wire

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

                  leaf signal-capability-flags {
                    type uint32;
                    description
                      "Sig Capability flags";
                  }

                  leaf context {
                    type uint16;
                    description "Context";
                  }

                  leaf sequence-resync-threshold {
                    type uint16;
                    description
                      "Sequence Resync Threshold";
                  }

                  leaf bound {
                    type boolean;
                    description "Bound";
                  }

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }

                  leaf interface-list-next-hop-valid {
                    type boolean;
                    description
                      "IS IFlist Next Hop Valid";
                  }

                  leaf backup-configured {
                    type boolean;
                    description
                      "Backup Pseudowire Configured";
                  }

                  leaf redundancy-role {
                    type L2fib-pw-redundancy-role;
                    description
                      "Redundancy Role";
                  }

                  leaf active {
                    type boolean;
                    description
                      "PW is active and forwarding";
                  }

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

                  leaf pw-load-balance-type {
                    type L2fib-load-bal;
                    description
                      "Type of load-balancing";
                  }

                  leaf pw-flow-label-tx {
                    type boolean;
                    description
                      "Pseudowire flow label TX enabled";
                  }

                  leaf grouping-supported {
                    type boolean;
                    description
                      "Grouping supported";
                  }

                  leaf group-id {
                    type uint32;
                    description
                      "PW Group Id";
                  }

                  leaf group-state {
                    type L2fib-group-state;
                    description
                      "Group State";
                  }

                  leaf global-id {
                    type uint32;
                    description "Global Id";
                  }

                  leaf ac-id {
                    type uint32;
                    description "Ac Id";
                  }

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

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

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

                  leaf is-srv6 {
                    type boolean;
                    description
                      "PW is over SRv6";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment

              container bridge-port-operational-info {
                description
                  "Bridge port operational information";
                container operational-information {
                  description
                    "L2 operational information";
                  leaf mtu {
                    type uint32;
                    description "MTU";
                  }

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

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

                  leaf number-of-macs {
                    type uint32;
                    description
                      "numberOfMacs";
                  }

                  leaf admin-disabled {
                    type boolean;
                    description
                      "Is administratively disabled";
                  }

                  leaf flooding-disabled {
                    type boolean;
                    description
                      "Is flooding disabled";
                  }

                  leaf flood-unknown-unicast-enabled {
                    type boolean;
                    description
                      "Is flooding unknown unicast disabled";
                  }

                  leaf mac-limit-action {
                    type Mgmt-l2fib-mac-limit-action;
                    description
                      "MAC limit action";
                  }

                  leaf mac-limit-threshold {
                    type uint32;
                    units "percentage";
                    description
                      "MAC limit percentage recovery threshold";
                  }

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

                  leaf mac-port-down-flush-disabled {
                    type boolean;
                    description
                      "Is MAC port down flush disabled";
                  }

                  leaf mac-limit-notification-type {
                    type Mgmt-l2fib-mac-limit-notify;
                    description
                      "MAC limit notification";
                  }

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

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

                  leaf mac-secure-action {
                    type Mgmt-l2fib-mac-sec-action;
                    description
                      "MAC secure action";
                  }

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

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

                  leaf mac-aging-type {
                    type Mgmt-l2fib-mac-aging;
                    description
                      "MAC aging type";
                  }

                  leaf l2mc-src-traffic-enabled {
                    type uint32;
                    description
                      "L2MC Source Traffic Enabled";
                  }

                  leaf storm-control-unicast-enabled {
                    type boolean;
                    description
                      "Is unicast storm control enabled";
                  }

                  leaf storm-control-broadcast-enabled {
                    type boolean;
                    description
                      "Is broadcast storm control enabled";
                  }

                  leaf storm-control-multicast-enabled {
                    type boolean;
                    description
                      "Is multicast storm control enabled";
                  }

                  leaf storm-control-unicast-rate-unit {
                    type L2fib-storm-control-rate-unit;
                    description
                      "Storm control unicast rate unit";
                  }

                  leaf storm-control-broadcast-rate-unit {
                    type L2fib-storm-control-rate-unit;
                    description
                      "Storm control broadcast rate unit";
                  }

                  leaf storm-control-multicast-rate-unit {
                    type L2fib-storm-control-rate-unit;
                    description
                      "Storm control multicast rate unit";
                  }

                  leaf dhcp-enabled {
                    type boolean;
                    description
                      "Is DHCP snooping enabled";
                  }

                  leaf dhcp-trusted {
                    type boolean;
                    description
                      "Is DHCP trusted";
                  }

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

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

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

                  leaf is-dai-addr-validation-destination-mac-enabled {
                    type boolean;
                    description
                      "Is DAI Destination MAC Validation enabled";
                  }

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

                  leaf is-ipsg-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-vpls-flood-optimization-enabled {
                    type boolean;
                    description
                      "Is MMRP  Flood Optimization Enabled";
                  }

                  leaf igmp-snoop-enabled {
                    type boolean;
                    description
                      "Is IGMP snooping enabled";
                  }

                  leaf igmp-snoop-profile-enabled {
                    type boolean;
                    description
                      "Is IGMP snooping profile enabled";
                  }

                  leaf igmp-flood-forward-enabled {
                    type boolean;
                    description
                      "Is IGMP flood forwarding enabled";
                  }

                  leaf igmp-mroute-port-enabled {
                    type boolean;
                    description
                      "Is mrouter port";
                  }

                  leaf igmp-route-guard-enabled {
                    type boolean;
                    description
                      "Is router gurad enabled";
                  }

                  leaf mld-snoop-enabled {
                    type boolean;
                    description
                      "Is MLD snooping enabled";
                  }

                  leaf mld-snoop-profile-enabled {
                    type boolean;
                    description
                      "Is MLD snooping profile enabled";
                  }

                  leaf mld-flood-forward-enabled {
                    type boolean;
                    description
                      "Is MLD flood forwarding enabled";
                  }

                  leaf mld-mroute-port-enabled {
                    type boolean;
                    description
                      "Is mrouter port";
                  }

                  leaf mld-route-guard-enabled {
                    type boolean;
                    description
                      "Is router gurad enabled";
                  }

                  leaf stp-participating {
                    type boolean;
                    description
                      "Is Spanning Tree Protocol participating";
                  }

                  leaf bvi-configured {
                    type boolean;
                    description
                      "Is BVI Interface configured";
                  }

                  leaf is-bvi-up {
                    type boolean;
                    description
                      "Is BVI state UP";
                  }

                  leaf is-vni-enabled {
                    type boolean;
                    description
                      "Is VNI enabled";
                  }

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

                  leaf unknown-unicast-flooding-disabled {
                    type boolean;
                    description
                      "Unknown Unicast Flooding is disabled";
                  }

                  leaf is-pbbevpn-enabled {
                    type boolean;
                    description
                      "Is PBBEVPN enabled";
                  }

                  leaf is-swmac-learning {
                    type boolean;
                    description
                      "Is SW MAC learning enabled";
                  }

                  leaf is-evpn-flow-label {
                    type boolean;
                    description
                      "Is EVPN Flow Label enabled";
                  }

                  leaf is-evpn-cw-disable {
                    type boolean;
                    description
                      "Is EVPN CW disabled";
                  }

                  leaf msti {
                    type uint32;
                    description
                      "Multi-spanning tree instance";
                  }

                  leaf is-p2mp-pw-enabled {
                    type boolean;
                    description
                      "Is P2MP PW enabled";
                  }

                  leaf is-igmp-snoop-enabled {
                    type boolean;
                    description
                      "Is IGMP Snooping admin enabled";
                  }

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

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

                  leaf is-ves {
                    type boolean;
                    description
                      "Is Virtual Ethernet Segement feature enabled";
                  }

                  list feature {
                    description
                      "Feature information";
                    container dhcp {
                      when
                        "../feature-type = 'l2fib-feature-dhcp-snooping'" {
                        description
                          "../feature_type = 'L2FIB_FEATURE_DHCP_SNOOPING'";
                      }
                      description "dhcp";
                      leaf profile-name {
                        type string;
                        description
                          "Feature profile name";
                      }
                    }  // container dhcp

                    container igmp {
                      when
                        "../feature-type = 'l2fib-feature-igmp-snooping'" {
                        description
                          "../feature_type = 'L2FIB_FEATURE_IGMP_SNOOPING'";
                      }
                      description "igmp";
                      leaf profile-name {
                        type string;
                        description
                          "Feature profile name";
                      }
                    }  // container igmp

                    container mld {
                      when
                        "../feature-type = 'l2fib-feature-mld-snooping'" {
                        description
                          "../feature_type = 'L2FIB_FEATURE_MLD_SNOOPING'";
                      }
                      description "mld";
                      leaf profile-name {
                        type string;
                        description
                          "Feature profile name";
                      }
                    }  // container mld

                    leaf feature-type {
                      type L2fib-feature;
                      description
                        "feature type";
                    }
                  }  // list feature
                }  // container operational-information

                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 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 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";
                }
              }  // container bridge-port-operational-info

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

              leaf shg-id {
                type uint32;
                description
                  "Split horizon group ID";
              }

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

              leaf number-of-hw-mac {
                type uint32;
                description
                  "Number of HW MAC addresses";
              }

              leaf number-of-sw-mac {
                type uint32;
                description
                  "Number of SW MAC addresses";
              }

              leaf number-of-mcast-routes {
                type uint32;
                description
                  "Number of MCAST Routes";
              }

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

              leaf mac-limit-action {
                type Mgmt-l2fib-mac-limit-action;
                description
                  "MAC limit action";
              }

              leaf flooding-disabled {
                type boolean;
                description
                  "Is flooding disabled";
              }

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

              leaf mac-port-down-flush-disabled {
                type boolean;
                description
                  "Is MAC port down flush disabled";
              }

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

              leaf aging-time-out {
                type uint32;
                description "Aging timeout";
              }
            }  // list l2fib-bridge-port
          }  // container l2fib-bridge-ports

          container l2fibmac-details {
            description
              "Bridge MAC detail information";
            list l2fibmac-detail {
              description
                "MAC Detail information";
              leaf address {
                type yang:mac-address;
                description
                  "Static MAC address";
              }

              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Group Name";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              container segment {
                description "Segment";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  leaf interface-name {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  leaf vsp-vlan {
                    type uint16;
                    description
                      "VLAN-Switched Port VLAN ID";
                  }
                }  // container ac

                container pbb {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-pbb'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_PBB'";
                  }
                  description "pbb";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }
                }  // container pbb

                container vni {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-vni'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_VNI'";
                  }
                  description "vni";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }

                  leaf parent-if {
                    type xr:Interface-name;
                    description
                      "Parent NVE Interface";
                  }
                }  // container vni

                container evpn {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "evpn";
                  leaf xcid {
                    type uint32;
                    description
                      "Xconnect ID";
                  }
                }  // container evpn

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac' and ../data-type != 'mgmt-l2fib-data-type-pbb' and ../data-type != 'mgmt-l2fib-data-type-vni' and ../data-type != 'mgmt-l2fib-data-type-evpn'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_PBB' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_VNI' and .
./DataType != 'MGMT_L2FIB_DATA_TYPE_EVPN'";
                  }
                  description "pw";
                  leaf pw-id {
                    type uint64;
                    description
                      "Pseudowire ID";
                  }

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

                  leaf pseudo-wire-id-type {
                    type L2fib-pw-id;
                    description
                      "Pseudowire ID type";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container segment

              container evpn-ctx {
                description "Evpn Context";
                container mcast-ole {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-moi'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_MOI'";
                  }
                  description "mcast ole";
                  leaf tunnel-endpoint-id {
                    type uint32;
                    description
                      "Tunnel Endpoint ID";
                  }

                  leaf mcast-encapsulation {
                    type uint32;
                    description
                      "Inclusive mcast transport encap";
                  }

                  leaf moi-type {
                    type L2vpn-evpn-moi;
                    description
                      "MOI Next Hop type";
                  }

                  leaf next-hop-ipv6-addr {
                    type inet:ipv6-address;
                    description
                      "Next Hop IPv6 address";
                  }

                  leaf mcast-label {
                    type uint32;
                    description
                      "Inclusive mcast label";
                  }

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

                  leaf sr-te-bsid {
                    type uint32;
                    description
                      "SR-TE Binding Label (BSID)";
                  }

                  leaf srv6-te-bsid {
                    type inet:ipv6-address;
                    description
                      "SRv6-TE Binding SID";
                  }
                }  // container mcast-ole

                leaf data-type {
                  type Mgmt-l2fib-bridge-mac-evpn-ctx;
                  description "DataType";
                }

                leaf esi-id {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-esi-id'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_ESI_ID'";
                  }
                  type uint16;
                  description "EsiID";
                }

                leaf local-label {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-local-label'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_LOCAL_LABEL'";
                  }
                  type uint32;
                  description "LocalLabel";
                }

                leaf bp-ifh {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-bp-ifh'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_BP_IFH'";
                  }
                  type xr:Interface-name;
                  description "BP IFH";
                }

                leaf internal-id {
                  when
                    "../data-type = 'mgmt-l2fib-bridge-mac-evpn-ctx-internal-id'" {
                    description
                      "../DataType =
'MGMT_L2FIB_BRIDGE_MAC_EVPN_CTX_INTERNAL_ID'";
                  }
                  type uint32;
                  description "InternalID";
                }
              }  // container evpn-ctx

              container next-hop {
                description "Next Hop";
                leaf type {
                  type L2fib-nhop;
                  description "Nexthop Type";
                }

                leaf next-hop-address {
                  type inet:ipv4-address;
                  description "NHOP Address";
                }

                leaf next-hop-address-v6 {
                  type inet:ipv6-address;
                  description
                    "NHOP Address V6";
                }

                leaf next-hop-te-interface-name {
                  type xr:Interface-name;
                  description
                    "NHOP (SR-)TE Interface";
                }

                leaf next-hop-lsm-id {
                  type uint32;
                  description "NHOP LSM ID";
                }

                leaf next-hop-sr-te-bsid {
                  type uint32;
                  description
                    "NHOP SR-TE Binding Label (BSID)";
                }

                leaf next-hop-internal-label {
                  type uint32;
                  description
                    "NHOP Internal Label";
                }

                leaf next-hop-internal-id {
                  type uint32;
                  description
                    "NHOP Internal ID";
                }

                leaf pin-down-interface-name {
                  type xr:Interface-name;
                  description
                    "Pin-down Interface Name";
                }

                leaf ecd-platform-data-valid {
                  type boolean;
                  description
                    "Is Platform ECD Data Valid";
                }

                leaf ecd-platform-data-length {
                  type uint32;
                  description
                    "Platform ECD Data Length";
                }

                leaf children-count {
                  type uint32;
                  description
                    "Children Count";
                }

                leaf children-evpn-ole-count {
                  type uint32;
                  description
                    "Children EVPN OLE Count";
                }

                leaf children-mac-count {
                  type uint32;
                  description
                    "Children MAC Count";
                }

                leaf children-pwhe-mp-count {
                  type uint32;
                  description
                    "Children PW-HE MainPort Count";
                }

                leaf children-ac-backup-count {
                  type uint32;
                  description
                    "Children AC-BACKUP Count";
                }

                leaf children-pw-ipv4-interface-list-count {
                  type uint32;
                  description
                    "Children PW IP-IFL Count";
                }

                leaf children-pw-te-tunnel-interface-list-count {
                  type uint32;
                  description
                    "Children PW IFH-IFL Count";
                }
              }  // container next-hop

              leaf platform-is-hw-learn {
                type uint8;
                description
                  "Platform is HW Learn";
              }

              leaf node-id {
                type xr:Node-id;
                description "Nodeid list";
              }

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

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

              leaf bmac-configured {
                type boolean;
                description
                  "Flag: Configured BMAC";
              }

              leaf vni-l3-flag {
                type boolean;
                description "Flag: L3 Vxlan";
              }

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

              leaf l3-encapsulationvlan-id {
                type uint16;
                description
                  "L3 encapsulation Vlan ID";
              }

              leaf next-hop-valid {
                type boolean;
                description
                  "IS Next Hop Valid";
              }

              leaf peer-vtep-ip {
                type inet:ipv4-address;
                description
                  "Peer VTEP IP for this MAC Address";
              }

              leaf flag-extension {
                type uint16;
                description
                  "MAC Flag Extension";
              }

              leaf vni {
                type uint32;
                description
                  "VNI Information";
              }
            }  // list l2fibmac-detail
          }  // container l2fibmac-details

          container l2fib-bridge-domain-names {
            description
              "Bridge Domain forwarding detail";
            list l2fib-bridge-domain-name {
              description
                "Specify Bridge Domain Name";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Name of the Bridge group";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

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

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

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

              leaf mac-limit-action {
                type Mgmt-l2fib-mac-limit-action;
                description
                  "MAC limit action";
              }

              leaf flood-disabled {
                type boolean;
                description
                  "Is flooding disabled";
              }

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

              leaf mac-port-down-flush-disabled {
                type boolean;
                description
                  "Is MAC port down flush disabled";
              }

              leaf admin-disabled {
                type boolean;
                description
                  "Is administratively disabled";
              }

              leaf bridge-port-count {
                type uint32;
                description
                  "Number of bridge ports";
              }

              leaf number-of-shg {
                type uint32;
                description
                  "Number of split horizon groups";
              }

              leaf number-of-hwmac {
                type uint32;
                description
                  "Number of HW MAC addresses";
              }

              leaf number-of-swmac {
                type uint32;
                description
                  "Number of SW MAC addresses";
              }

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

              leaf aging-time-out {
                type uint32;
                description "Aging timeout";
              }

              leaf msti {
                type uint32;
                description
                  "multi-spanning tree instance";
              }

              leaf l2mc-src-traffic-enabled {
                type uint32;
                description
                  "L2MC traffic source on BD";
              }
            }  // list l2fib-bridge-domain-name
          }  // container l2fib-bridge-domain-names

          container l2fib-evpn-incl-mcast-leafs {
            description
              "L2FIB EVPN inclusive multicast leaf table";
            list l2fib-evpn-incl-mcast-leaf {
              description
                "L2FIB EVPN inclusive multicast leaf";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Name of the Bridge group";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf xcid {
                type xr:Hex-integer;
                description "XC ID";
              }

              container l2fib-evpn-incl-mcast-oles {
                description
                  "L2FIB EVPN inclusive multicast output list
element table";
                list l2fib-evpn-incl-mcast-ole {
                  description
                    "L2FIB EVPN inclusive multicast output list
element";
                  leaf moi-type {
                    type L2fib-evpn-moi;
                    description
                      "EVPN MOI Type";
                  }

                  leaf next-hop-address {
                    type inet:ip-address-no-zone;
                    description
                      "Next Hop Address";
                  }

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

                  leaf sr-te-bsid {
                    type uint32 {
                      range "0..1048575";
                    }
                    description
                      "SR-TE Binding Label (BSID)";
                  }

                  leaf srv6-te-bsid {
                    type inet:ip-address-no-zone;
                    description
                      "SRv6-TE Binding SID";
                  }

                  container mcast-ole {
                    description
                      "Mcast Ole Info";
                    leaf tunnel-endpoint-id {
                      type uint32;
                      description
                        "Tunnel Endpoint ID";
                    }

                    leaf mcast-encapsulation {
                      type uint32;
                      description
                        "Inclusive mcast transport encap";
                    }

                    leaf moi-type {
                      type L2vpn-evpn-moi;
                      description
                        "MOI Next Hop type";
                    }

                    leaf next-hop-ipv6-addr {
                      type inet:ipv6-address;
                      description
                        "Next Hop IPv6 address";
                    }

                    leaf mcast-label {
                      type uint32;
                      description
                        "Inclusive mcast label";
                    }

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

                    leaf sr-te-bsid {
                      type uint32;
                      description
                        "SR-TE Binding Label (BSID)";
                    }

                    leaf srv6-te-bsid {
                      type inet:ipv6-address;
                      description
                        "SRv6-TE Binding SID";
                    }
                  }  // container mcast-ole

                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  leaf is-bound {
                    type boolean;
                    description "Is bound";
                  }

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

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }
                }  // list l2fib-evpn-incl-mcast-ole
              }  // container l2fib-evpn-incl-mcast-oles

              container l2fib-evpn-incl-mcast-leaf-info {
                description
                  "L2FIB EVPN inclusive multicast leaf information";
                leaf bridge-domain-name {
                  type string;
                  description
                    "Bridge-domain name";
                }

                leaf bridge-domain-id {
                  type uint32;
                  description "bdid value";
                }

                leaf xcid {
                  type uint32;
                  description "xcid value";
                }

                leaf is-bound {
                  type boolean;
                  description "Is bound";
                }
              }  // container l2fib-evpn-incl-mcast-leaf-info
            }  // list l2fib-evpn-incl-mcast-leaf
          }  // container l2fib-evpn-incl-mcast-leafs

          container l2fib-mroute-ports {
            description
              "multicast bridge port information ";
            list l2fib-mroute-port {
              description
                "Multicast Port Information";
              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf xcid {
                type xr:Hex-integer;
                description "XConnect ID";
              }

              leaf originating-ip {
                type inet:ip-address-no-zone;
                description "Originating IP";
              }

              leaf label {
                type uint32 {
                  range "0..1048575";
                }
                description "NextHop Label";
              }

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

              leaf group {
                type inet:ipv4-address-no-zone;
                description
                  "Group IP Address";
              }

              container forward-stats {
                description
                  "Forwarding Statistics";
                container forward-stat {
                  description "fwd stats";
                  container mulicast {
                    when
                      "../data-type = 'mgmt-l2fib-stats-type-mcast'" {
                      description
                        "../DataType = 'MGMT_L2FIB_STATS_TYPE_MCAST'";
                    }
                    description "mulicast";
                    container multicast-forward-stat {
                      description
                        "forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-forward-stat

                    container received-stat {
                      description
                        "received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container received-stat

                    container punt {
                      description
                        "punted stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container punt

                    container drop {
                      description
                        "dropped stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container drop

                    container multicast-core-forward-stat {
                      description
                        "core forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-core-forward-stat

                    container core-received-stat {
                      description
                        "core received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container core-received-stat
                  }  // container mulicast

                  leaf data-type {
                    type Mgmt-l2fib-stats-data;
                    description "DataType";
                  }
                }  // container forward-stat
              }  // container forward-stats

              container source-prefix {
                description "Source Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container source-prefix

              container destination-prefix {
                description
                  "Destination Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container destination-prefix

              leaf bridge-id {
                type uint32;
                description "Bridge Id";
              }

              leaf ac-interface-handle {
                type xr:Interface-name;
                description "AC If handle";
              }

              leaf df-from-bridge-port {
                type boolean;
                description
                  "DF/NDF state derived from Bridge Port";
              }

              leaf is-ndf {
                type boolean;
                description
                  "Non-Designated Forwarder";
              }

              leaf leaf-pointer {
                type uint32;
                description "Leaf Ptr";
              }

              leaf pw-id {
                type string {
                  length "0..40";
                }
                description "PW ID";
              }

              leaf next-hop-address {
                type inet:ipv4-address;
                description
                  "NHOP IP Address";
              }

              leaf isid {
                type uint32;
                description "Isid Id";
              }

              leaf csfl {
                type uint32;
                description "Csfl Id";
              }

              leaf sat-id {
                type uint16;
                description "Sat Id";
              }

              leaf is-ole-offloaded {
                type boolean;
                description "Ole Offloaded";
              }

              leaf is-ole-master {
                type boolean;
                description "Ole Master";
              }

              leaf is-topo-hub-and-spoke {
                type boolean;
                description
                  "Topo HubAndSpoke";
              }

              leaf is-evpn-xid {
                type boolean;
                description "EVPN Ole";
              }

              leaf evpn-next-hop {
                type inet:ipv6-address;
                description
                  "EVPN Ole NextHop";
              }
            }  // list l2fib-mroute-port
          }  // container l2fib-mroute-ports

          container l2fib-summary {
            description
              "L2FIB Summary information";
            container xconnect-summary {
              description
                "xconnect db summary info";
              leaf xconnect-count {
                type uint32;
                description
                  "total number of entries";
              }

              leaf xconnect-up-count {
                type uint32;
                description
                  "number of up entries";
              }

              leaf xconnect-down-count {
                type uint32;
                description
                  "number of down entries";
              }

              leaf ac-to-pw-count-mpls {
                type uint32;
                description
                  "number of ac->pw-mpls entries";
              }

              leaf ac-to-pw-count-iid {
                type uint32;
                description
                  "number of ac->pw-iid entries";
              }

              leaf ac-to-pw-count-l2tp {
                type uint32;
                description
                  "number of ac->pw-l2tp entries";
              }

              leaf ac-to-pw-count-l2tp-ip-v6 {
                type uint32;
                description
                  "number of ac->pw-l2tp-ipv6 entries";
              }

              leaf ac-to-pw-count-l2tpv2 {
                type uint32;
                description
                  "number of ac->pw-l2tpv2 entries";
              }

              leaf ac-to-ac-count {
                type uint32;
                description
                  "number of ac->ac entries";
              }

              leaf ac-to-unknown-count {
                type uint32;
                description
                  "number of ac->unknown type entries";
              }

              leaf mon-sess-to-pw-count {
                type uint32;
                description
                  "number of monitor_session->pw entries";
              }

              leaf mon-sess-to-unknown-count {
                type uint32;
                description
                  "number of monitor_session->unknown type entries";
              }

              leaf ac-to-bp-count {
                type uint32;
                description
                  "number of ac->bp entries";
              }

              leaf pw-to-bp-count {
                type uint32;
                description
                  "number of pw->bp entries";
              }

              leaf pw-to-unknown-count {
                type uint32;
                description
                  "number of pw->unknown type entries";
              }

              leaf pbb-to-bp-count {
                type uint32;
                description
                  "number of pbb->bp entries";
              }

              leaf pbb-to-unknown-count {
                type uint32;
                description
                  "number of pbb->unknown type entries";
              }

              leaf vni-to-bp-count {
                type uint32;
                description
                  "number of vni->bp entries";
              }

              leaf vni-to-unknown-count {
                type uint32;
                description
                  "number of vni->unknown type entries";
              }

              leaf evpn-to-bp-count {
                type uint32;
                description
                  "number of evpn->bp entries";
              }

              leaf evpn-to-unknown-count {
                type uint32;
                description
                  "number of evpn->unknown type entries";
              }

              leaf ac-down-count-aib {
                type uint32;
                description
                  "number of down acs with reason aib";
              }

              leaf ac-down-count-l2vpn {
                type uint32;
                description
                  "number of down acs with reason l2vpn";
              }

              leaf ac-down-count-l3fib {
                type uint32;
                description
                  "number of down acs with reason fib";
              }

              leaf ac-down-count-vpdn {
                type uint32;
                description
                  "number of down acs with reason vpdn";
              }

              leaf vpws-pw-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to VPWS PW
invalid xid";
              }

              leaf vpls-pw-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to VPLS PW
invalid xid";
              }

              leaf virtual-ac-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to Virtual AC
invalid xid";
              }

              leaf pbb-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to PBB invalid
xid";
              }

              leaf vni-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to VNI invalid
xid";
              }

              leaf evpn-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to EVPN invalid
xid";
              }

              leaf vpls-pw-max-exceeded-drop-cnt {
                type uint32;
                description
                  "number of xc updates dropped due to max VPLS PWs
exceeded";
              }

              leaf bundle-ac-max-exceeded-drop-cnt {
                type uint32;
                description
                  "number of xc updates dropped due to max Bundle
ACs exceeded";
              }

              leaf global-invalid-xid-drop-count {
                type uint32;
                description
                  "number of xc updates dropped due to Global
invalid xid";
              }

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

              leaf bp-count {
                type uint32;
                description
                  "number of bridge-port xconnects";
              }

              leaf pwhe-l2-if-count {
                type uint32;
                description
                  "number of PWHE L2IF xconnects";
              }
            }  // container xconnect-summary

            container next-hop-summary {
              description
                "nhop db summry info";
              container internal-label {
                description
                  "Internal Label nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container internal-label

              container internal-id {
                description
                  "Internal ID nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container internal-id

              container mpls {
                description
                  "MPLS nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container mpls

              container l2tp {
                description
                  "L2TP nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container l2tp

              container lsm {
                description
                  "LSM nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container lsm

              container p2mp-tunnels {
                description
                  "P2MPtun nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container p2mp-tunnels

              container ipv6 {
                description
                  "IPv6 nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container ipv6

              container te-tunnels {
                description
                  "(SR-)TE Tunnel nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container te-tunnels

              container sr-te-bsid {
                description
                  "SR-TE Binding Label (BSID) nexthop summary";
                leaf next-hop-count {
                  type uint32;
                  description
                    "total number of nhops";
                }

                leaf bound-next-hop-count {
                  type uint32;
                  description
                    "number of bound nhops";
                }

                leaf unbound-next-hop-count {
                  type uint32;
                  description
                    "number of unbound nhops";
                }

                leaf next-hop-pending-registration-count {
                  type uint32;
                  description
                    "number of nhops pending registration with fib ";
                }
              }  // container sr-te-bsid
            }  // container next-hop-summary

            container l2tp-disposition-summary {
              description
                "L2TP disposition object summary";
              leaf l2tp-disposition-session-count {
                type uint32;
                description
                  "number of l2tp disposition session objects";
              }

              leaf bound-l2tp-disposition-session-count {
                type uint32;
                description
                  "number of bound l2tp disposition objects";
              }

              leaf unbound-l2tp-disposition-session-count {
                type uint32;
                description
                  "number of unbound l2tp disposition objects";
              }
            }  // container l2tp-disposition-summary

            container bridge-domain-summary {
              description
                "Bridge-domain summary info";
              leaf bridge-domain-count {
                type uint32;
                description
                  "Number of bridge-domains";
              }

              leaf bridge-domain-drop-count {
                type uint32;
                description
                  "Number of bridge-domain updates dropped";
              }

              leaf bridge-domain-with-bvi-count {
                type uint32;
                description
                  "Number of bridge-domains with BVI";
              }

              leaf bridge-domain-with-p2mp-enabled {
                type uint32;
                description
                  "Number of bridge-domains with P2MP enabled";
              }

              leaf bridge-domain-with-pbbevpn-enabled {
                type uint32;
                description
                  "Number of bridge-domains with PBB EVPN enabled";
              }

              leaf bridge-domain-with-evpn-enabled {
                type uint32;
                description
                  "Number of bridge-domains with EVPN enabled";
              }
            }  // container bridge-domain-summary

            container mac-summary {
              description "mac summary info";
              leaf mac-counts-invalid {
                type boolean;
                description
                  "Flag to show if MAC counts aren't valid";
              }

              leaf local-mac-count {
                type uint32;
                description
                  "number of locally learnt macs";
              }

              leaf remote-mac-count {
                type uint32;
                description
                  "number of remotely learned macs";
              }

              leaf static-mac-count {
                type uint32;
                description
                  "number of static macs";
              }

              leaf routed-mac-count {
                type uint32;
                description
                  "number of routed macs";
              }

              leaf mac-count {
                type uint32;
                description
                  "number of all macs";
              }

              leaf sbmac-count {
                type uint32;
                description
                  "number of Source BMACs";
              }

              leaf bmac-count {
                type uint32;
                description
                  "number of BMACs";
              }
            }  // container mac-summary

            container ipmac-summary {
              description
                "ipmac summary info";
              leaf ip-mac-counts-valid {
                type boolean;
                description
                  "IPMacCountsValid";
              }

              leaf ipv4mac-count-local {
                type uint32;
                description
                  "number of local ipv4macs ";
              }

              leaf ipv4mac-count-remote {
                type uint32;
                description
                  "number of remote ipv4macs ";
              }

              leaf ipv6mac-count-local {
                type uint32;
                description
                  "number of local ipv6macs ";
              }

              leaf ipv6mac-count-remote {
                type uint32;
                description
                  "number of remote ipv6macs ";
              }

              leaf ipmac-count {
                type uint32;
                description
                  "number of all ipmacs";
              }
            }  // container ipmac-summary

            container queue-summary {
              description
                "queue summary info";
              leaf inline-cnt {
                type uint32;
                description
                  "number of objects in inline queue";
              }

              leaf retry-cnt {
                type uint32;
                description
                  "number of objects in retry queue";
              }

              leaf update-cnt {
                type uint32;
                description
                  "number of objects in update queues";
              }

              leaf del-cnt {
                type uint32;
                description
                  "number of objects in delete queues";
              }
            }  // container queue-summary

            container evpn-summary {
              description
                "evpn summary info";
              leaf total-count {
                type uint32;
                description
                  "Number of EVPN Multicast Replication lists";
              }

              leaf isid-count {
                type uint32;
                description
                  "Number of ISID leaves";
              }

              leaf default-count {
                type uint32;
                description
                  "Number of default leaves";
              }

              leaf stitching-count {
                type uint32;
                description
                  "Number of stitching leaves";
              }
            }  // container evpn-summary

            container global-cfg {
              description
                "Global configuration";
              leaf load-balance-type {
                type L2fib-load-bal;
                description
                  "Type of Load-Balancing";
              }

              leaf evpn-imc-label-block-base {
                type uint32;
                description
                  "Base of label range in use for EVPN IMC PD";
              }

              leaf evpn-imc-label-block-size {
                type uint16;
                description
                  "Size of label range in use for EVPN IMC PD";
              }
            }  // container global-cfg

            container ptree-summary {
              description
                "P2MP PTree summary info";
              leaf total-ptree-count {
                type uint32;
                description
                  "Number of PTree objects";
              }

              leaf mldp-enabled-ptree-count {
                type uint32;
                description
                  "Number of MLDP enabled PTree objects";
              }

              leaf lmrib-mldp-ptree-count {
                type uint32;
                description
                  "Number of MLDP PTree Objects owned by LMRIB";
              }

              leaf rsvp-te-enabled-ptree-count {
                type uint32;
                description
                  "Number of RSVP-TE enabled PTree objects";
              }

              leaf lmrib-rsvp-te-ptree-count {
                type uint32;
                description
                  "Number of RSVP-TE PTree Objects owned by LMRIB";
              }
            }  // container ptree-summary

            container pw-group-summary {
              description
                "PWGroup summary info";
              leaf plat-grouping-supported {
                type boolean;
                description
                  "Platform supports Grouping";
              }

              leaf total-pw-groups {
                type uint32;
                description
                  "Total number of PWGROUP objects";
              }

              leaf pw-groups-down {
                type uint32;
                description
                  "Number of PWGROUP objects down";
              }
            }  // container pw-group-summary

            container pwhe-mp-summary {
              description
                "PWHE Main-port summary info";
              leaf total-count {
                type uint32;
                description
                  "Number of PWHE Main-ports";
              }
            }  // container pwhe-mp-summary
          }  // container l2fib-summary

          container l2fib-nve-peers {
            description "NVE Peer Table";
            list l2fib-nve-peer {
              description
                "The attributes for a particular NVE Peer";
              leaf xc-uint-id {
                type xr:Hex-integer;
                description "XC ID";
              }

              leaf vniid {
                type xr:Hex-integer;
                description "VNI ID";
              }

              leaf vtep-address {
                type inet:ipv4-address-no-zone;
                description
                  "VTEP IP Address";
              }

              leaf nve-if {
                type xr:Interface-name;
                description
                  "Parent NVE IF Handle";
              }

              leaf vn-iid {
                type uint32;
                description "VNI ID";
              }

              leaf vte-pip {
                type inet:ipv4-address;
                description
                  "Peer VTEP IP Address";
              }
            }  // list l2fib-nve-peer
          }  // container l2fib-nve-peers

          container l2fib-mmrps {
            description "mmrp information";
            list l2fib-mmrp {
              description
                "Bridge Domain Mmrp Information";
              leaf bd-name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf source {
                type yang:mac-address;
                description
                  "Source Mac Address";
              }

              leaf group {
                type yang:mac-address;
                description
                  "Group Mac Address";
              }

              container source-prefix {
                description "Source Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container source-prefix

              container destination-prefix {
                description
                  "Destination Prefix";
                leaf proto {
                  type L2fib-prefix-proto-info;
                  description
                    "The prefix protocol";
                }

                leaf prefix-length {
                  type uint16;
                  description
                    "The prefix length";
                }

                leaf prefix {
                  type string;
                  description "The prefix";
                }
              }  // container destination-prefix

              container forward-stats {
                description
                  "Forwarding Statistics";
                container forward-stat {
                  description "fwd stats";
                  container mulicast {
                    when
                      "../data-type = 'mgmt-l2fib-stats-type-mcast'" {
                      description
                        "../DataType = 'MGMT_L2FIB_STATS_TYPE_MCAST'";
                    }
                    description "mulicast";
                    container multicast-forward-stat {
                      description
                        "forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-forward-stat

                    container received-stat {
                      description
                        "received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container received-stat

                    container punt {
                      description
                        "punted stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container punt

                    container drop {
                      description
                        "dropped stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container drop

                    container multicast-core-forward-stat {
                      description
                        "core forwarded stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container multicast-core-forward-stat

                    container core-received-stat {
                      description
                        "core received stats";
                      leaf packets {
                        type uint64;
                        description
                          "Number of packets";
                      }

                      leaf bytes {
                        type uint64;
                        units "byte";
                        description
                          "Number of bytes";
                      }
                    }  // container core-received-stat
                  }  // container mulicast

                  leaf data-type {
                    type Mgmt-l2fib-stats-data;
                    description "DataType";
                  }
                }  // container forward-stat
              }  // container forward-stats

              container irb-info {
                description
                  "IRB Information";
                leaf mxid-ac-interface-handle {
                  type xr:Interface-name;
                  description
                    "Master XID AC If handle";
                }

                leaf mxid-pw-id {
                  type uint32;
                  description
                    "Master XID PW ID";
                }

                leaf mxid-next-hop-address {
                  type inet:ipv4-address;
                  description
                    "Master XID NHOP IP Address";
                }

                leaf irb-plat-data-len {
                  type uint16;
                  units "byte";
                  description
                    "Platform data bytes";
                }

                list irb-plat-data {
                  max-elements 16;
                  description
                    "IRB platform data";
                  leaf entry {
                    type uint32;
                    description
                      "IRB platform data";
                  }
                }  // list irb-plat-data
              }  // container irb-info

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

              leaf xid-count {
                type uint16;
                description "Count of XIDs";
              }

              leaf platform-data-length {
                type uint8;
                description
                  "The mcast platform data len";
              }

              leaf platform-data {
                type yang:hex-string;
                description
                  "The mcast platform data";
              }

              leaf hardware-information {
                type yang:hex-string;
                description
                  "Platform Hardware info";
              }

              leaf bridge-domain-name {
                type string {
                  length "0..66";
                }
                description "Bridge Name";
              }
            }  // list l2fib-mmrp
          }  // container l2fib-mmrps

          container l2fib-evpn-ip6macs {
            description
              "EVPN IPv6-MAC Table";
            list l2fib-evpn-ip6mac {
              description
                "The attributes for a particular EVPN IPv6-MAC
               Entry";
              leaf bdid {
                type Bridge-id-range;
                description "BD ID";
              }

              leaf ip-address {
                type inet:ip-address-no-zone;
                description "IP Address";
              }

              leaf is-local {
                type boolean;
                description
                  "Entry is locally learned";
              }

              leaf mac-address {
                type yang:mac-address;
                description "MAC Address";
              }

              container ip-address-xr {
                description "IP Address";
                leaf addr-type {
                  type L2fib-ip-addr;
                  description "addr type";
                }

                leaf ip {
                  type inet:ipv6-address;
                  description "ip";
                }
              }  // container ip-address-xr

              leaf bdid-xr {
                type uint32;
                description "BD ID";
              }

              leaf mac-address-xr {
                type yang:mac-address;
                description "MAC Address";
              }

              leaf arp-nd-sync-pending {
                type boolean;
                description
                  "Sync to ARP/ND Process Pending";
              }

              leaf arp-nd-probe-pending {
                type boolean;
                description
                  "Probe to ARP/ND Process Pending";
              }

              leaf arp-nd-delete-pending {
                type boolean;
                description
                  "Delete to ARP/ND Process Pending";
              }

              leaf is-local-xr {
                type boolean;
                description
                  "IP-MAC Route is locally learned";
              }
            }  // list l2fib-evpn-ip6mac
          }  // container l2fib-evpn-ip6macs

          container l2fib-pwhe-main-port-hardware-egresses {
            description
              "PWHE Main-port Hardware Egress Table";
            list l2fib-pwhe-main-port-hardware-egress {
              key "interface-name";
              description
                "PWHE Main-port H/W Egress Info";
              leaf interface-name {
                type xr:Interface-name;
                description "PWHE Main-port";
              }

              leaf next-hop-valid {
                type boolean;
                description
                  "IS Next Hop Valid";
              }

              leaf next-hop-address {
                type inet:ipv4-address;
                description
                  "Next Hop Address";
              }

              leaf pseudo-wire-type {
                type uint32;
                description
                  "Pseudowire type";
              }

              leaf generic-interface-list-id {
                type uint32;
                description
                  "Generic Interface List ID";
              }

              leaf internal-label {
                type uint32;
                description "Internal label";
              }

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

              leaf control-word-enabled {
                type boolean;
                description
                  "Control Word Enabled";
              }
            }  // list l2fib-pwhe-main-port-hardware-egress
          }  // container l2fib-pwhe-main-port-hardware-egresses

          container l2fib-evpn-incl-mcast-leaf-hardware-egresses {
            description
              "L2FIB hardware ingress EVPN inclusive
             multicast leaf table";
            list l2fib-evpn-incl-mcast-leaf-hardware-egress {
              description
                "L2FIB hardware egress EVPN inclusive
               multicast leaf";
              leaf bd-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Name of the Bridge group";
              }

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..65";
                }
                description
                  "Bridge Domain Name";
              }

              leaf xcid {
                type xr:Hex-integer;
                description "XC ID";
              }

              container l2fib-evpn-incl-mcast-oles {
                description
                  "L2FIB EVPN inclusive multicast output list
element table";
                list l2fib-evpn-incl-mcast-ole {
                  description
                    "L2FIB EVPN inclusive multicast output list
element";
                  leaf moi-type {
                    type L2fib-evpn-moi;
                    description
                      "EVPN MOI Type";
                  }

                  leaf next-hop-address {
                    type inet:ip-address-no-zone;
                    description
                      "Next Hop Address";
                  }

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

                  leaf sr-te-bsid {
                    type uint32 {
                      range "0..1048575";
                    }
                    description
                      "SR-TE Binding Label (BSID)";
                  }

                  leaf srv6-te-bsid {
                    type inet:ip-address-no-zone;
                    description
                      "SRv6-TE Binding SID";
                  }

                  container mcast-ole {
                    description
                      "Mcast Ole Info";
                    leaf tunnel-endpoint-id {
                      type uint32;
                      description
                        "Tunnel Endpoint ID";
                    }

                    leaf mcast-encapsulation {
                      type uint32;
                      description
                        "Inclusive mcast transport encap";
                    }

                    leaf moi-type {
                      type L2vpn-evpn-moi;
                      description
                        "MOI Next Hop type";
                    }

                    leaf next-hop-ipv6-addr {
                      type inet:ipv6-address;
                      description
                        "Next Hop IPv6 address";
                    }

                    leaf mcast-label {
                      type uint32;
                      description
                        "Inclusive mcast label";
                    }

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

                    leaf sr-te-bsid {
                      type uint32;
                      description
                        "SR-TE Binding Label (BSID)";
                    }

                    leaf srv6-te-bsid {
                      type inet:ipv6-address;
                      description
                        "SRv6-TE Binding SID";
                    }
                  }  // container mcast-ole

                  container next-hop {
                    description "Next Hop";
                    leaf type {
                      type L2fib-nhop;
                      description
                        "Nexthop Type";
                    }

                    leaf next-hop-address {
                      type inet:ipv4-address;
                      description
                        "NHOP Address";
                    }

                    leaf next-hop-address-v6 {
                      type inet:ipv6-address;
                      description
                        "NHOP Address V6";
                    }

                    leaf next-hop-te-interface-name {
                      type xr:Interface-name;
                      description
                        "NHOP (SR-)TE Interface";
                    }

                    leaf next-hop-lsm-id {
                      type uint32;
                      description
                        "NHOP LSM ID";
                    }

                    leaf next-hop-sr-te-bsid {
                      type uint32;
                      description
                        "NHOP SR-TE Binding Label (BSID)";
                    }

                    leaf next-hop-internal-label {
                      type uint32;
                      description
                        "NHOP Internal Label";
                    }

                    leaf next-hop-internal-id {
                      type uint32;
                      description
                        "NHOP Internal ID";
                    }

                    leaf pin-down-interface-name {
                      type xr:Interface-name;
                      description
                        "Pin-down Interface Name";
                    }

                    leaf ecd-platform-data-valid {
                      type boolean;
                      description
                        "Is Platform ECD Data Valid";
                    }

                    leaf ecd-platform-data-length {
                      type uint32;
                      description
                        "Platform ECD Data Length";
                    }

                    leaf children-count {
                      type uint32;
                      description
                        "Children Count";
                    }

                    leaf children-evpn-ole-count {
                      type uint32;
                      description
                        "Children EVPN OLE Count";
                    }

                    leaf children-mac-count {
                      type uint32;
                      description
                        "Children MAC Count";
                    }

                    leaf children-pwhe-mp-count {
                      type uint32;
                      description
                        "Children PW-HE MainPort Count";
                    }

                    leaf children-ac-backup-count {
                      type uint32;
                      description
                        "Children AC-BACKUP Count";
                    }

                    leaf children-pw-ipv4-interface-list-count {
                      type uint32;
                      description
                        "Children PW IP-IFL Count";
                    }

                    leaf children-pw-te-tunnel-interface-list-count {
                      type uint32;
                      description
                        "Children PW IFH-IFL Count";
                    }
                  }  // container next-hop

                  leaf is-bound {
                    type boolean;
                    description "Is bound";
                  }

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

                  leaf next-hop-valid {
                    type boolean;
                    description
                      "IS Next Hop Valid";
                  }
                }  // list l2fib-evpn-incl-mcast-ole
              }  // container l2fib-evpn-incl-mcast-oles

              container l2fib-evpn-incl-mcast-leaf-info {
                description
                  "L2FIB EVPN inclusive multicast leaf information";
                leaf bridge-domain-name {
                  type string;
                  description
                    "Bridge-domain name";
                }

                leaf bridge-domain-id {
                  type uint32;
                  description "bdid value";
                }

                leaf xcid {
                  type uint32;
                  description "xcid value";
                }

                leaf is-bound {
                  type boolean;
                  description "Is bound";
                }
              }  // container l2fib-evpn-incl-mcast-leaf-info
            }  // list l2fib-evpn-incl-mcast-leaf-hardware-egress
          }  // container l2fib-evpn-incl-mcast-leaf-hardware-egresses

          container l2fib-dhcp-binding-summaries {
            description
              "DHCP binding forwarding summary";
            list l2fib-dhcp-binding-summary {
              key "xcid";
              description
                "Specify DHCP binding summary";
              leaf xcid {
                type xr:Hex-integer;
                description "XConnect ID";
              }

              container port {
                description
                  "Union of Port information";
                container ac {
                  when
                    "../data-type = 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType = 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "ac";
                  leaf interface-name {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  leaf vsp-vlan {
                    type uint16;
                    description
                      "VLAN-Switched Port VLAN ID";
                  }
                }  // container ac

                container pw {
                  when
                    "../data-type != 'mgmt-l2fib-data-type-ac'" {
                    description
                      "../DataType != 'MGMT_L2FIB_DATA_TYPE_AC'";
                  }
                  description "pw";
                  leaf pw-id {
                    type uint64;
                    description
                      "Pseudowire ID";
                  }

                  leaf next-hop-address {
                    type inet:ipv4-address;
                    description
                      "Next Hop Address";
                  }

                  leaf pseudo-wire-id-type {
                    type L2fib-pw-id;
                    description
                      "Pseudowire ID type";
                  }
                }  // container pw

                leaf data-type {
                  type Mgmt-l2fib-data;
                  description "DataType";
                }
              }  // container port

              leaf bindings {
                type uint32;
                description
                  "DHCP binding count";
              }
            }  // list l2fib-dhcp-binding-summary
          }  // container l2fib-dhcp-binding-summaries

          container l2fib-pwhe-main-port-hardware-ingresses {
            description
              "PWHE Main-port Hardware Ingress Table";
            list l2fib-pwhe-main-port-hardware-ingress {
              key "interface-name";
              description
                "PWHE Main-port H/W Ingress Info";
              leaf interface-name {
                type xr:Interface-name;
                description "PWHE Main-port";
              }

              leaf next-hop-valid {
                type boolean;
                description
                  "IS Next Hop Valid";
              }

              leaf next-hop-address {
                type inet:ipv4-address;
                description
                  "Next Hop Address";
              }

              leaf pseudo-wire-type {
                type uint32;
                description
                  "Pseudowire type";
              }

              leaf generic-interface-list-id {
                type uint32;
                description
                  "Generic Interface List ID";
              }

              leaf internal-label {
                type uint32;
                description "Internal label";
              }

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

              leaf control-word-enabled {
                type boolean;
                description
                  "Control Word Enabled";
              }
            }  // list l2fib-pwhe-main-port-hardware-ingress
          }  // container l2fib-pwhe-main-port-hardware-ingresses

          leaf node-id {
            type xr:Node-id;
            description
              "The identifier for the node";
          }
        }  // list node
      }  // container nodes
    }  // container l2vpn-forwarding

    container l2vpnv2 {
      config false;
      description
        "L2VPN operational data to support active and
       standby. L2VPN has been deprecated";
      container standby {
        description
          "Standby L2VPN operational data";
        container discoveries {
          description "Discovery Table";
          list discovery {
            description
              "VPLS Discovery information";
            leaf service-name {
              type L2vpn-service;
              description "Service type";
            }

            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "Group Name";
            }

            leaf vpn-name {
              type xr:Cisco-ios-xr-string {
                length "1..27";
              }
              description "VPN Name";
            }

            container signalling-info {
              description
                "Info about signalling protocol";
              container bgp-sig-info {
                when
                  "../ad-signalling-method = 'l2vpn-ad-sig-method-bgp'" {
                  description
                    "../ADSignallingMethod =
'L2VPN_AD_SIG_METHOD_BGP'";
                }
                description "bgp sig info";
                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";
                  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";
                    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
                  }  // list label-block
                }  // list edge

                list redge {
                  description
                    "List of edge ids";
                  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";
                    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
                  }  // list label-block
                }  // list redge
              }  // 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";
                container local-vpls-id {
                  description
                    "Local VPLS-ID";
                  container auto {
                    when
                      "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                      description
                        "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                    }
                    description "auto";
                    leaf asn {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf vpn-id {
                      type uint32;
                      description "VPN ID";
                    }
                  }  // 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";
                    leaf two-byte-as {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf four-byte-index {
                      type uint32;
                      description
                        "4 Byte Index";
                    }
                  }  // 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";
                    leaf ipv4-address {
                      type inet:ipv4-address;
                      description
                        "IPv4 Address";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container v4-addr

                  leaf vpls-id-type {
                    type L2vpn-ad-vpls-id;
                    description
                      "VPLS ID TYPE";
                  }
                }  // 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";
                  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";
                  }
                }  // list remote-nlri
              }  // container ldp-sig-info

              leaf ad-signalling-method {
                type L2vpn-ad-sig-method;
                description
                  "ADSignallingMethod";
              }
            }  // 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";
            }
          }  // list discovery
        }  // container discoveries

        container flexible-xconnect-service-summary {
          description
            "Flexible XConnect Service summary information";
          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";
          }
        }  // container flexible-xconnect-service-summary

        container main-interfaces {
          description "Main Interface";
          list main-interface {
            key "interface-name";
            description
              "Main Interface Table";
            container main-interface-instances {
              description
                "Main Interface Instance table";
              list main-interface-instance {
                key "instance";
                description
                  "Main Interface Instance";
                container main-interface-instance-info {
                  description
                    "Main Interface Instance info";
                  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";
                  }
                }  // container main-interface-instance-info

                container main-interface-instance-bridge-ports {
                  description
                    "Main Interface Instance Bridge Port table";
                  list main-interface-instance-bridge-port {
                    key "bridge-port";
                    description
                      "Main Interface Bridge Port info";
                    leaf bridge-port {
                      type xr:Interface-name;
                      description
                        "Bridge Port";
                    }

                    leaf bridge-port-xr {
                      type xr:Interface-name;
                      description
                        "Bridge port ifhandle";
                    }

                    leaf instance-id {
                      type uint32;
                      description
                        "Instance ID";
                    }
                  }  // list main-interface-instance-bridge-port
                }  // container main-interface-instance-bridge-ports

                leaf instance {
                  type Msti-range;
                  description "Instance";
                }
              }  // list main-interface-instance
            }  // container main-interface-instances

            container main-interface-info {
              description
                "Main Interface info";
              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";
              }
            }  // container main-interface-info

            leaf interface-name {
              type xr:Interface-name;
              description "Main interface";
            }
          }  // list main-interface
        }  // container main-interfaces

        container iccp-sm {
          description
            "ICCP-based Service Multi-homing operational data";
          container iccp-sm-summary {
            description
              "ICCP-based Service Multi-homing database
summary";
            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";
            }
          }  // container iccp-sm-summary

          container iccp-groups {
            description "ICCP Group Table";
            list iccp-group {
              key "group-id";
              description "ICCP Group";
              container iccp-group-info {
                description
                  "ICCP Group Information";
                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";
                  container local-port {
                    description
                      "Local port info";
                    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";
                    }
                  }  // container local-port

                  container remote-port {
                    description
                      "Remote port info";
                    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";
                    }
                  }  // 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?";
                  }
                }  // list ports
              }  // container iccp-group-info

              container iccp-ports {
                description
                  "ICCP Port Table";
                list iccp-port {
                  key "interface";
                  description "ICCP Port";
                  leaf interface {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  container local-port {
                    description
                      "Local port info";
                    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";
                    }
                  }  // container local-port

                  container remote-port {
                    description
                      "Remote port info";
                    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";
                    }
                  }  // 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?";
                  }
                }  // list iccp-port
              }  // container iccp-ports

              leaf group-id {
                type uint32 {
                  range "1..4294967295";
                }
                description "Group ID";
              }
            }  // list iccp-group
          }  // container iccp-groups
        }  // container iccp-sm

        container bridge-summary {
          description
            "Bridge Domain summary information";
          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";
          }
        }  // container bridge-summary

        container nsr {
          description
            "L2VPN NSR information";
          container 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";
            }
          }  // container failover-status

          container nsr-status {
            description
              "L2VPN NSR status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // container nsr-status

          container issu-status {
            description
              "L2VPN ISSU Status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // 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";
            leaf app-type {
              type L2vpn-id-mgr-app-bag;
              description "App type";
            }

            leaf sent-ids {
              type uint32;
              description
                "Number of XIDs transferred";
            }
          }  // list xid-info

          list report-card {
            description
              "L2VPN Collaborator 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";
            }
          }  // list report-card
        }  // container nsr

        container preferred-paths {
          description "Preferred path Table";
          list preferred-path {
            description
              "Preferred path information";
            leaf preferred-type {
              type Preferred-path-option;
              description "Preferred type";
            }

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

            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";
              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";
              }
            }  // list virtual-circuit
          }  // list preferred-path
        }  // container preferred-paths

        container pseudowire-headend {
          description
            "Pseudowire Headend related operational data";
          container detail-interfaces {
            description "PW-HE Interfaces";
            list detail-interface {
              key "interface-name";
              description
                "PW-HE Interface detail";
              leaf interface-name {
                type xr:Interface-name;
                description
                  "PWHE Interface name";
              }

              container l2-address {
                description "Layer2 Address";
                container mac-address {
                  when
                    "../interface-type = 'pseudowire-ether'" {
                    description
                      "../InterfaceType = 'PseudowireEther'";
                  }
                  description "MAC address";
                  leaf mac-address {
                    type yang:mac-address;
                    description
                      "MAC Address";
                  }
                }  // container mac-address

                leaf interface-type {
                  type L2vpn-pwhe-intf;
                  description
                    "InterfaceType";
                }
              }  // container l2-address

              container generic-interface-list {
                description
                  "Generic Interface List";
                leaf generic-interface-list-name {
                  type string;
                  description
                    "Generic interface list name";
                }

                leaf id {
                  type uint32;
                  description
                    "Generic interface list ID";
                }

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

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

                  leaf interface-state {
                    type Pwhe-port-im-state;
                    description
                      "Interface Status";
                  }

                  leaf replicate-state {
                    type L2vpn-pwhe-iflist-rep-status;
                    description
                      "Replication status";
                  }

                  leaf misconfigured {
                    type int32;
                    description
                      "Interface misconfigured";
                  }
                }  // list interface-detail
              }  // container generic-interface-list

              leaf interface-state {
                type Pwhe-port-im-state;
                description
                  "Interface Status";
              }

              leaf admin-state {
                type Pwhe-port-im-state;
                description
                  "Interface Admin Status";
              }

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

              leaf bandwidth {
                type uint32;
                units "kbit/s";
                description
                  "Bandwidth (Kbps)";
              }

              leaf label {
                type uint32;
                description "Label";
              }

              leaf l2-overhead {
                type uint32;
                description "L2 Overhead";
              }

              leaf vctype {
                type uint32;
                description "VC Type";
              }

              leaf control-word {
                type int32;
                description "Control Word";
              }
            }  // list detail-interface
          }  // container detail-interfaces

          container summary {
            description
              "PW-HE interface summary";
            leaf interfaces {
              type uint32;
              description
                "Number of PW-HE interfaces";
            }

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

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

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

            leaf psuedowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces";
            }

            leaf up-psuedowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces up";
            }

            leaf down-pseudowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces down";
            }

            leaf admin-down-pseudowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces admin down";
            }

            leaf pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces";
            }

            leaf up-pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces up";
            }

            leaf down-pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces down";
            }

            leaf admin-down-pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces admin down";
            }
          }  // container summary
        }  // container pseudowire-headend

        container global-settings {
          description
            "L2VPN global settings";
          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";
          }
        }  // container global-settings

        container pwr {
          description
            "Pseudowire Routing Table";
          container summary {
            description
              "L2VPN Pseudowire Routing Summary";
            container rd-auto {
              description
                "Automatic Route Distingtuisher";
              container auto {
                when
                  "../rd = 'l2vpn-ad-rd-auto'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AUTO'";
                }
                description "auto";
                leaf router-id {
                  type inet:ipv4-address;
                  description
                    "BGP Router ID";
                }

                leaf auto-index {
                  type uint16;
                  description
                    "Auto-generated Index";
                }
              }  // container auto

              container two-byte-as {
                when
                  "../rd = 'l2vpn-ad-rd-as'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AS'";
                }
                description "two byte as";
                leaf two-byte-as {
                  type uint16;
                  description
                    "2 Byte AS Number";
                }

                leaf four-byte-index {
                  type uint32;
                  description "4 Byte Index";
                }
              }  // 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";
                leaf four-byte-as {
                  type uint32;
                  description
                    "4 Byte AS Number";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container four-byte-as

              container v4-addr {
                when
                  "../rd = 'l2vpn-ad-rd-v4-addr'" {
                  description
                    "../RD = 'L2VPN_AD_RD_V4ADDR'";
                }
                description "v4 addr";
                leaf ipv4-address {
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container v4-addr

              leaf rd {
                type L2vpn-ad-rd;
                description "RD";
              }
            }  // container rd-auto

            container rd-configured {
              description
                "Configured Route Distinguisher";
              container auto {
                when
                  "../rd = 'l2vpn-ad-rd-auto'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AUTO'";
                }
                description "auto";
                leaf router-id {
                  type inet:ipv4-address;
                  description
                    "BGP Router ID";
                }

                leaf auto-index {
                  type uint16;
                  description
                    "Auto-generated Index";
                }
              }  // container auto

              container two-byte-as {
                when
                  "../rd = 'l2vpn-ad-rd-as'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AS'";
                }
                description "two byte as";
                leaf two-byte-as {
                  type uint16;
                  description
                    "2 Byte AS Number";
                }

                leaf four-byte-index {
                  type uint32;
                  description "4 Byte Index";
                }
              }  // 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";
                leaf four-byte-as {
                  type uint32;
                  description
                    "4 Byte AS Number";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container four-byte-as

              container v4-addr {
                when
                  "../rd = 'l2vpn-ad-rd-v4-addr'" {
                  description
                    "../RD = 'L2VPN_AD_RD_V4ADDR'";
                }
                description "v4 addr";
                leaf ipv4-address {
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container v4-addr

              leaf rd {
                type L2vpn-ad-rd;
                description "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";
            }
          }  // container summary
        }  // container pwr

        container xconnect-mp2mp-ce2ces {
          description
            "XConnect MP2MP CE2CE Table";
          list xconnect-mp2mp-ce2ce {
            description
              "XConnect MP2MP CE2CE information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

            leaf mp2-mp-name {
              type xr:Cisco-ios-xr-string {
                length "1..26";
              }
              description "Mp2Mp Name";
            }

            leaf local-ceid {
              type uint32 {
                range "1..4294967295";
              }
              description "Local CE ID";
            }

            leaf remote-ceid {
              type uint32 {
                range "1..4294967295";
              }
              description "Remote CE ID";
            }

            container backup {
              description "LCR backup";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container backup

            container segment1 {
              description "Segment 1";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment1

            container segment2 {
              description "Segment 2";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment2

            container ce2ce {
              description "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";
              }
            }  // 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";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // list backup-segment
          }  // list xconnect-mp2mp-ce2ce
        }  // container xconnect-mp2mp-ce2ces

        container xconnects {
          description "XConnect Table";
          list xconnect {
            key "group-name xconnect-name";
            description
              "XConnect information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

            leaf xconnect-name {
              type string {
                length "1..38";
              }
              description "XConnect Name";
            }

            container backup {
              description "LCR backup";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container backup

            container segment1 {
              description "Segment 1";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment1

            container segment2 {
              description "Segment 2";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment2

            container ce2ce {
              description "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";
              }
            }  // 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";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // list backup-segment
          }  // list xconnect
        }  // container xconnects

        container xconnect-groups {
          description "XConnect group Table";
          list xconnect-group {
            key "group-name";
            description
              "XConnect group information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

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

            leaf number-xconnects {
              type uint32;
              description
                "Number of xconnects";
            }
          }  // list xconnect-group
        }  // container xconnect-groups

        container xconnect-mp2mps {
          description "XConnect MP2MP Table";
          list xconnect-mp2mp {
            key "group-name mp2-mp-name";
            description
              "XConnect MP2MP information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

            leaf mp2-mp-name {
              type xr:Cisco-ios-xr-string {
                length "1..26";
              }
              description "Mp2Mp Name";
            }

            container discovery {
              description
                "l2vpn xc auto discovery info";
              container rd-value {
                description
                  "Route Distinguisher";
                container auto {
                  when
                    "../rd = 'l2vpn-ad-rd-auto'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AUTO'";
                  }
                  description "auto";
                  leaf router-id {
                    type inet:ipv4-address;
                    description
                      "BGP Router ID";
                  }

                  leaf auto-index {
                    type uint16;
                    description
                      "Auto-generated Index";
                  }
                }  // container auto

                container two-byte-as {
                  when
                    "../rd = 'l2vpn-ad-rd-as'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rd = 'l2vpn-ad-rd-v4-addr'" {
                    description
                      "../RD = 'L2VPN_AD_RD_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                leaf rd {
                  type L2vpn-ad-rd;
                  description "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";
                container two-byte-as {
                  when
                    "../rt = 'l2vpn-ad-rt-as'" {
                    description
                      "../RT = 'L2VPN_AD_RT_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rt = 'l2vpn-ad-rt-v4-addr'" {
                    description
                      "../RT = 'L2VPN_AD_RT_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                container es-import {
                  when "../rt = 'es-import'" {
                    description
                      "../RT = 'ES_Import'";
                  }
                  description "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";
                  }
                }  // container es-import

                leaf rt {
                  type L2vpn-ad-rt;
                  description "RT";
                }
              }  // list import-rt

              list export-rt {
                description
                  "Export Route Targets";
                container two-byte-as {
                  when
                    "../rt = 'l2vpn-ad-rt-as'" {
                    description
                      "../RT = 'L2VPN_AD_RT_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rt = 'l2vpn-ad-rt-v4-addr'" {
                    description
                      "../RT = 'L2VPN_AD_RT_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                container es-import {
                  when "../rt = 'es-import'" {
                    description
                      "../RT = 'ES_Import'";
                  }
                  description "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";
                  }
                }  // container es-import

                leaf rt {
                  type L2vpn-ad-rt;
                  description "RT";
                }
              }  // list export-rt
            }  // 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";
            }
          }  // list xconnect-mp2mp
        }  // container xconnect-mp2mps

        container srte-policies {
          description "SRTE Policy Table";
          list srte-policy {
            description
              "SRTE Policy information";
            leaf color {
              type uint32;
              description "Policy Color";
            }

            leaf endpoint {
              type inet:ip-address-no-zone;
              description
                "Policy Endpoint IP Address";
            }

            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";
            }
          }  // list srte-policy
        }  // container srte-policies

        container indexes {
          description
            "ID Manager Index Table";
          list index {
            key "pool-id";
            description
              "ID Manager Index Pool";
            leaf pool-id {
              type xr:Hex-integer;
              description "Pool ID";
            }

            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";
            }
          }  // list index
        }  // container indexes

        container xconnect-summary {
          description
            "XConnect summary information";
          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";
          }
        }  // container xconnect-summary

        container proc-fsm {
          description
            "L2VPN Process FSM information";
          container 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";
            }
          }  // container failover-status

          container nsr-status {
            description
              "L2VPN NSR status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // container nsr-status

          container issu-status {
            description
              "L2VPN ISSU Status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // 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";
            leaf app-type {
              type L2vpn-id-mgr-app-bag;
              description "App type";
            }

            leaf sent-ids {
              type uint32;
              description
                "Number of XIDs transferred";
            }
          }  // list xid-info

          list report-card {
            description
              "L2VPN Collaborator 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";
            }
          }  // list report-card
        }  // container proc-fsm

        container mstp-ports {
          description
            "L2VPN MSTP Port Table";
          list mstp-port {
            key "interface";
            description
              "MSTP Port information";
            leaf interface {
              type xr:Interface-name;
              description "Interface";
            }

            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";
              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";
                leaf bdid {
                  type uint32;
                  description "BD ID";
                }

                leaf bdif-count {
                  type uint32;
                  description
                    "BD Intf Count";
                }
              }  // list bd-entry
            }  // list msti-entry
          }  // list mstp-port
        }  // container mstp-ports

        container generic-interface-list-details {
          description
            "L2VPN generic interface list Detail Table";
          list generic-interface-list-detail {
            key "interface-list-name";
            description
              "Generic Interface List detail information";
            leaf interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Generic Interface List Name";
            }

            container summary {
              description
                "Summary information";
              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";
                leaf interface-name {
                  type string;
                  description
                    "Interface name";
                }

                leaf pending-replications {
                  type uint32;
                  description
                    "Number of pending replications";
                }

                leaf not-supported-replications {
                  type uint32;
                  description
                    "Number of replications failed because
unsupported";
                }

                leaf is-fib-downloaded {
                  type boolean;
                  description
                    "Is interface downloaded to FIB";
                }
              }  // list interface
            }  // 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";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf pending-replications {
                type uint32;
                description
                  "Number of pending replications";
              }

              leaf not-supported-replications {
                type uint32;
                description
                  "Number of replications failed because
unsupported";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is interface downloaded to FIB";
              }
            }  // list interface

            list pseudowire-ether-range {
              description "PW-Ether ranges";
              leaf lower {
                type uint16;
                description "lower range";
              }

              leaf upper {
                type uint16;
                description "upper range";
              }
            }  // list pseudowire-ether-range

            list pseudowire-iw-range {
              description "PW-IW ranges";
              leaf lower {
                type uint16;
                description "lower range";
              }

              leaf upper {
                type uint16;
                description "upper range";
              }
            }  // list pseudowire-iw-range
          }  // list generic-interface-list-detail
        }  // container generic-interface-list-details

        container l2vpn-resource-state {
          description
            "L2VPN resource state information";
          leaf resource-out-of-memory-state {
            type uint32;
            description
              "L2VPN Out of memory state";
          }
        }  // container l2vpn-resource-state

        container bridge-domains {
          description
            "Bridge Domain Information";
          list bridge-domain {
            key "bridge-domain-group-name bridge-domain-name";
            description
              "Bridge Domain Information";
            container bridge-access-vfi-table {
              description
                "Bridge Domain Access VFI Table";
              container bridge-pws {
                description
                  "Bridge Domain Access/Core Pseudowire Table";
                list bridge-pw {
                  description
                    "Bridge Domain Pseudowire";
                  leaf neighbor {
                    type inet:ipv4-address-no-zone;
                    description
                      "Neighbor IPv4 address";
                  }

                  leaf pw-type {
                    type L2vpnpw;
                    description "PW Type";
                  }

                  leaf pseudowire-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Pseudowire ID";
                  }

                  leaf ve-id-vpls-id-0-3 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                  }

                  leaf vpls-id-4-7 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or Last 4 bytes of VPLS-ID";
                  }

                  container pseudowire {
                    description "Pseudowire";
                    container peer-id {
                      description "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";
                      }
                    }  // container peer-id

                    container encapsulation-info {
                      description
                        "Encapsulation specific pseudowire information";
                      container atom {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                        }
                        description "atom";
                        container local-agi {
                          description
                            "Local Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container local-agi

                        container remote-agi {
                          description
                            "Remote Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container remote-agi

                        container multi-segment-pseudowire-stats {
                          description
                            "Multisegment pseudowire statistics";
                          leaf received-packets {
                            type uint64;
                            description
                              "Packets received";
                          }

                          leaf received-bytes {
                            type uint64;
                            units "byte";
                            description
                              "Bytes received";
                          }
                        }  // 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";
                        }
                      }  // container atom

                      container l2tpv3 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                        }
                        description "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";
                        }
                      }  // container l2tpv3

                      container srv6 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                        }
                        description "srv6";
                        container srv6-headend-behavior {
                          description
                            "Headend behavior in use";
                          leaf type {
                            type Mgmt-srv6-headend;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // container srv6-headend-behavior

                        container srv6-endpoint-behavior {
                          description
                            "Endpoint behavior in use";
                          leaf type {
                            type Mgmt-srv6-endpoint;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // 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";
                          container sr-te-info {
                            description
                              "SR(v6)-TE Policy info from ODN";
                            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";
                            }
                          }  // container sr-te-info

                          container layer2-attributes {
                            description
                              "Layer 2 Attributes";
                            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";
                            }
                          }  // 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";
                            leaf srv6-sid {
                              type inet:ipv6-address;
                              description
                                "SRv6 SID";
                            }
                          }  // list srv6-sid-info
                        }  // list remote-path-buffer
                      }  // container srv6

                      leaf encapsulation {
                        type L2vpn-encap-method;
                        description
                          "Encapsulation";
                      }
                    }  // container encapsulation-info

                    container local-interface {
                      description
                        "Local interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container local-interface

                    container remote-interface {
                      description
                        "Remote interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container remote-interface

                    container preferred-path {
                      description
                        "MPLS Preferred Path";
                      container srte-policy {
                        when
                          "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                          description
                            "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                        }
                        description
                          "srte policy";
                        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";
                        }
                      }  // 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";
                        leaf te-named-tunnel {
                          type string;
                          description
                            "TE Tunnel Name";
                        }
                      }  // 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";
                      }
                    }  // container preferred-path

                    container local-signalling {
                      description
                        "Local signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container local-signalling

                    container remote-signalling {
                      description
                        "Remote signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container remote-signalling

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container p2mp-pw {
                      description
                        "P2MP Pseudowire Information";
                      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)";
                      }
                    }  // 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
                  }  // container pseudowire

                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

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

                  list static-mac {
                    description
                      "Static MAC addresses";
                    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";
                    }
                  }  // list static-mac
                }  // list bridge-pw
              }  // container bridge-pws
            }  // container bridge-access-vfi-table

            container bridge-core-vfi-table {
              description
                "Bridge Domain Core VFI Table";
              container bridge-pws {
                description
                  "Bridge Domain Access/Core Pseudowire Table";
                list bridge-pw {
                  description
                    "Bridge Domain Pseudowire";
                  leaf neighbor {
                    type inet:ipv4-address-no-zone;
                    description
                      "Neighbor IPv4 address";
                  }

                  leaf pw-type {
                    type L2vpnpw;
                    description "PW Type";
                  }

                  leaf pseudowire-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Pseudowire ID";
                  }

                  leaf ve-id-vpls-id-0-3 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                  }

                  leaf vpls-id-4-7 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or Last 4 bytes of VPLS-ID";
                  }

                  container pseudowire {
                    description "Pseudowire";
                    container peer-id {
                      description "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";
                      }
                    }  // container peer-id

                    container encapsulation-info {
                      description
                        "Encapsulation specific pseudowire information";
                      container atom {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                        }
                        description "atom";
                        container local-agi {
                          description
                            "Local Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container local-agi

                        container remote-agi {
                          description
                            "Remote Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container remote-agi

                        container multi-segment-pseudowire-stats {
                          description
                            "Multisegment pseudowire statistics";
                          leaf received-packets {
                            type uint64;
                            description
                              "Packets received";
                          }

                          leaf received-bytes {
                            type uint64;
                            units "byte";
                            description
                              "Bytes received";
                          }
                        }  // 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";
                        }
                      }  // container atom

                      container l2tpv3 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                        }
                        description "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";
                        }
                      }  // container l2tpv3

                      container srv6 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                        }
                        description "srv6";
                        container srv6-headend-behavior {
                          description
                            "Headend behavior in use";
                          leaf type {
                            type Mgmt-srv6-headend;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // container srv6-headend-behavior

                        container srv6-endpoint-behavior {
                          description
                            "Endpoint behavior in use";
                          leaf type {
                            type Mgmt-srv6-endpoint;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // 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";
                          container sr-te-info {
                            description
                              "SR(v6)-TE Policy info from ODN";
                            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";
                            }
                          }  // container sr-te-info

                          container layer2-attributes {
                            description
                              "Layer 2 Attributes";
                            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";
                            }
                          }  // 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";
                            leaf srv6-sid {
                              type inet:ipv6-address;
                              description
                                "SRv6 SID";
                            }
                          }  // list srv6-sid-info
                        }  // list remote-path-buffer
                      }  // container srv6

                      leaf encapsulation {
                        type L2vpn-encap-method;
                        description
                          "Encapsulation";
                      }
                    }  // container encapsulation-info

                    container local-interface {
                      description
                        "Local interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container local-interface

                    container remote-interface {
                      description
                        "Remote interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container remote-interface

                    container preferred-path {
                      description
                        "MPLS Preferred Path";
                      container srte-policy {
                        when
                          "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                          description
                            "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                        }
                        description
                          "srte policy";
                        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";
                        }
                      }  // 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";
                        leaf te-named-tunnel {
                          type string;
                          description
                            "TE Tunnel Name";
                        }
                      }  // 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";
                      }
                    }  // container preferred-path

                    container local-signalling {
                      description
                        "Local signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container local-signalling

                    container remote-signalling {
                      description
                        "Remote signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container remote-signalling

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container p2mp-pw {
                      description
                        "P2MP Pseudowire Information";
                      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)";
                      }
                    }  // 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
                  }  // container pseudowire

                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

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

                  list static-mac {
                    description
                      "Static MAC addresses";
                    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";
                    }
                  }  // list static-mac
                }  // list bridge-pw
              }  // container bridge-pws
            }  // container bridge-core-vfi-table

            container bridge-acs {
              description
                "Bridge Domain Attachment Circuit Table";
              list bridge-ac {
                key "interface-name";
                description
                  "Bridge Domain Attachment Circuit";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                container attachment-circuit {
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container security-parameters {
                  description
                    "Security Parameters";
                  container base {
                    description
                      "Basic Security Parameters";
                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container base

                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

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

                list static-mac {
                  description
                    "Static MAC addresses";
                  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";
                  }
                }  // list static-mac

                list bvimac {
                  description
                    "BVI MAC addresses";
                  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";
                  }
                }  // list bvimac
              }  // list bridge-ac
            }  // container bridge-acs

            container bridge-access-pws {
              description
                "Bridge Domain Access Pseudowire Table";
              list bridge-access-pw {
                description
                  "Bridge Domain Access Pseudowire";
                leaf neighbor {
                  type inet:ipv4-address-no-zone;
                  description
                    "Neighbor IPv4 address";
                }

                leaf pw-type {
                  type L2vpnpw;
                  description "PW Type";
                }

                leaf pseudowire-id {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description
                    "Pseudowire ID";
                }

                leaf ve-id-vpls-id-0-3 {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                }

                leaf vpls-id-4-7 {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "Zero or Last 4 bytes of VPLS-ID";
                }

                container pseudowire {
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudowire

                container security-parameters {
                  description
                    "Security Parameters";
                  container base {
                    description
                      "Basic Security Parameters";
                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container base

                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

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

                list static-mac {
                  description
                    "Static MAC addresses";
                  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";
                  }
                }  // list static-mac
              }  // list bridge-access-pw
            }  // container bridge-access-pws

            container bridge-domain-info {
              description
                "Bridge Domain Information";
              container security-parameters {
                description
                  "Security parameters";
                container storm-control {
                  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";
                  }
                }  // 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";
                }
              }  // container security-parameters

              container pbb-parameters {
                description "PBB parameters";
                container pbb-edge {
                  when
                    "../type = 'l2vpn-bridge-type-pbb-edge'" {
                    description
                      "../Type = 'L2VPN_BRIDGE_TYPE_PBB_EDGE'";
                  }
                  description "PBB Edge";
                  container edge-port {
                    description
                      "PBB Edge Port";
                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container security-parameters

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // 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";
                      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";
                      }
                    }  // list bmac-mapping
                  }  // 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";
                  }
                }  // container pbb-edge

                container pbb-core {
                  when
                    "../type = 'l2vpn-bridge-type-pbb-core'" {
                    description
                      "../Type = 'L2VPN_BRIDGE_TYPE_PBB_CORE'";
                  }
                  description "PBB Core";
                  container core-port {
                    description
                      "PBB Core Port";
                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // 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";
                    }
                  }  // container core-port

                  leaf num-ass-edge {
                    type uint32;
                    description
                      "Number of Associated PBB Edges";
                  }
                }  // container pbb-core

                leaf type {
                  type L2vpn-bridge;
                  description "Type";
                }
              }  // container pbb-parameters

              container evpn-parameters {
                description
                  "EVPN parameters";
                container evpn-port {
                  description "EVPN Port";
                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

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

                  leaf evpn-port-state {
                    type L2vpn-virtualport-state;
                    description
                      "EVPN Port State";
                  }
                }  // container evpn-port

                leaf evi {
                  type uint32;
                  description "E-VPN id";
                }
              }  // container evpn-parameters

              container vni-parameters {
                description "VNI parameters";
                container security-parameters {
                  description
                    "Security Parameters";
                  container base {
                    description
                      "Basic Security Parameters";
                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container base

                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // 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";
                  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";
                  }
                }  // list static-mac
              }  // container vni-parameters

              container rd {
                description
                  "Route Distinguisher";
                container auto {
                  when
                    "../rd = 'l2vpn-ad-rd-auto'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AUTO'";
                  }
                  description "auto";
                  leaf router-id {
                    type inet:ipv4-address;
                    description
                      "BGP Router ID";
                  }

                  leaf auto-index {
                    type uint16;
                    description
                      "Auto-generated Index";
                  }
                }  // container auto

                container two-byte-as {
                  when
                    "../rd = 'l2vpn-ad-rd-as'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rd = 'l2vpn-ad-rd-v4-addr'" {
                    description
                      "../RD = 'L2VPN_AD_RD_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                leaf rd {
                  type L2vpn-ad-rd;
                  description "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";
                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";
                }
              }  // list mac-filter

              list bridge-vfi {
                description
                  "Virtual Forwarding Interfaces";
                container discovery-information {
                  description
                    "Auto Discovery information";
                  container rd-value {
                    description
                      "Route Distinguisher";
                    container auto {
                      when
                        "../rd = 'l2vpn-ad-rd-auto'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AUTO'";
                      }
                      description "auto";
                      leaf router-id {
                        type inet:ipv4-address;
                        description
                          "BGP Router ID";
                      }

                      leaf auto-index {
                        type uint16;
                        description
                          "Auto-generated Index";
                      }
                    }  // container auto

                    container two-byte-as {
                      when
                        "../rd = 'l2vpn-ad-rd-as'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rd = 'l2vpn-ad-rd-v4-addr'" {
                        description
                          "../RD = 'L2VPN_AD_RD_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf rd {
                      type L2vpn-ad-rd;
                      description "RD";
                    }
                  }  // container rd-value

                  container vpls-id {
                    description "VPLS ID";
                    container auto {
                      when
                        "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                        description
                          "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                      }
                      description "auto";
                      leaf asn {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf vpn-id {
                        type uint32;
                        description "VPN ID";
                      }
                    }  // 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";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf vpls-id-type {
                      type L2vpn-ad-vpls-id;
                      description
                        "VPLS ID TYPE";
                    }
                  }  // 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";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list import-rt

                  list export-rt {
                    description
                      "List of export route targets";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list export-rt
                }  // 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";
                  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";
                  }
                }  // list p2mp-information
              }  // list bridge-vfi

              list bridge-access-vfi {
                description
                  "Access Virtual Forwarding Interfaces";
                container discovery-information {
                  description
                    "Auto Discovery information";
                  container rd-value {
                    description
                      "Route Distinguisher";
                    container auto {
                      when
                        "../rd = 'l2vpn-ad-rd-auto'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AUTO'";
                      }
                      description "auto";
                      leaf router-id {
                        type inet:ipv4-address;
                        description
                          "BGP Router ID";
                      }

                      leaf auto-index {
                        type uint16;
                        description
                          "Auto-generated Index";
                      }
                    }  // container auto

                    container two-byte-as {
                      when
                        "../rd = 'l2vpn-ad-rd-as'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rd = 'l2vpn-ad-rd-v4-addr'" {
                        description
                          "../RD = 'L2VPN_AD_RD_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf rd {
                      type L2vpn-ad-rd;
                      description "RD";
                    }
                  }  // container rd-value

                  container vpls-id {
                    description "VPLS ID";
                    container auto {
                      when
                        "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                        description
                          "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                      }
                      description "auto";
                      leaf asn {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf vpn-id {
                        type uint32;
                        description "VPN ID";
                      }
                    }  // 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";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf vpls-id-type {
                      type L2vpn-ad-vpls-id;
                      description
                        "VPLS ID TYPE";
                    }
                  }  // 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";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list import-rt

                  list export-rt {
                    description
                      "List of export route targets";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list export-rt
                }  // 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";
                  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";
                  }
                }  // list p2mp-information
              }  // list bridge-access-vfi
            }  // container bridge-domain-info

            leaf bridge-domain-group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Bridge Domain Group Name";
            }

            leaf bridge-domain-name {
              type xr:Cisco-ios-xr-string {
                length "1..27";
              }
              description
                "Bridge Domain Name";
            }
          }  // list bridge-domain
        }  // container bridge-domains

        container discovery-summary {
          description
            "Discovery summary information";
          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";
          }
        }  // container discovery-summary

        container g8032 {
          description "G8032 information";
          container g8032-rings {
            description "G8032 Ring table";
            list g8032-ring {
              key "ring-name";
              description "G8032 Ring";
              container g8032-ring-detail {
                description
                  "G8032 Ring detailed information";
                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
              }  // container g8032-ring-detail

              container g8032-ring-instance-summaries {
                description
                  "G8032 Ring Instance summary table";
                list g8032-ring-instance-summary {
                  key "instance";
                  description
                    "G8032 Ring Instance summary information";
                  leaf instance {
                    type uint32;
                    description "Instance";
                  }

                  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
                }  // list g8032-ring-instance-summary
              }  // container g8032-ring-instance-summaries

              container g8032-ring-summary {
                description
                  "G8032 Ring summary information";
                leaf ring-name {
                  type string;
                  description
                    "Name of the ring";
                }

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

                leaf port1 {
                  type string;
                  description "Port 1";
                }
              }  // container g8032-ring-summary

              container g8032-ring-instance-details {
                description
                  "G8032 Ring Instance detail table";
                list g8032-ring-instance-detail {
                  key "instance";
                  description
                    "G8032 Ring Instance detailed information";
                  leaf instance {
                    type G8032-ring-instance-range;
                    description "Instance";
                  }

                  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
                }  // list g8032-ring-instance-detail
              }  // container g8032-ring-instance-details

              leaf ring-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "Ring Name";
              }
            }  // list g8032-ring
          }  // container g8032-rings
        }  // container g8032

        container pseudowire-classes {
          description
            "List of pseudowire classes";
          list pseudowire-class {
            key "pseudowire-class-name";
            description
              "Pseudowire class information";
            leaf pseudowire-class-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Pseudowire Class Name";
            }

            container encapsulation-info {
              description
                "Encapsulation specific pseudowire information";
              container l2tpv3 {
                when
                  "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                  description
                    "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                }
                description "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 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";
                }
              }  // container l2tpv3

              leaf encapsulation {
                type L2vpn-encap-method;
                description "Encapsulation";
              }
            }  // container encapsulation-info

            container preferred-path {
              description
                "MPLS Preferred Path";
              container srte-policy {
                when
                  "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                  description
                    "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                }
                description "srte policy";
                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";
                }
              }  // 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";
                leaf te-named-tunnel {
                  type string;
                  description
                    "TE Tunnel Name";
                }
              }  // 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";
              }
            }  // container preferred-path

            container local-source-address {
              description
                "Local 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";
              }
            }  // 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";
            }
          }  // list pseudowire-class
        }  // container pseudowire-classes

        container l2vpn-collaborators {
          description
            "L2VPN collaborator information";
          container collaborator-statistics {
            description
              "Collaborator Statistics";
            list count {
              max-elements 1;
              description "count";
              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";
              }
            }  // list count
          }  // container collaborator-statistics
        }  // container l2vpn-collaborators

        container mvrp {
          description "MVRP";
          container mvrp-main-ports {
            description
              "MVRP Main Port Table";
            list mvrp-main-port {
              key "main-port-interface-name";
              description "MVRP Main Port";
              container mvrp-main-port-info {
                description
                  "MVRP Main Port Information";
                container default-bridge-port {
                  description
                    "Trunk or default Bridge Port";
                  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";
                    leaf lower {
                      type uint16;
                      description "Lower";
                    }

                    leaf upper {
                      type uint16;
                      description "Upper";
                    }
                  }  // list vlan-range
                }  // 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";
                }
              }  // container mvrp-main-port-info

              container mvrp-bridge-ports {
                description
                  "MVRP Bridge Port Table";
                list mvrp-bridge-port {
                  key "interface-name";
                  description
                    "MVRP Bridge Port Information";
                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Bridge Port Interface Name";
                  }

                  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";
                    leaf lower {
                      type uint16;
                      description "Lower";
                    }

                    leaf upper {
                      type uint16;
                      description "Upper";
                    }
                  }  // list vlan-range
                }  // list mvrp-bridge-port
              }  // container mvrp-bridge-ports

              leaf main-port-interface-name {
                type xr:Interface-name;
                description
                  "Main Port interface";
              }
            }  // list mvrp-main-port
          }  // container mvrp-main-ports
        }  // container mvrp

        container generic-interface-lists {
          description
            "L2VPN generic interface list Table";
          list generic-interface-list {
            key "interface-list-name";
            description
              "Generic Interface List information";
            leaf interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Generic Interface List Name";
            }

            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";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf pending-replications {
                type uint32;
                description
                  "Number of pending replications";
              }

              leaf not-supported-replications {
                type uint32;
                description
                  "Number of replications failed because
unsupported";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is interface downloaded to FIB";
              }
            }  // list interface
          }  // list generic-interface-list
        }  // container generic-interface-lists

        container mstp-vlans {
          description
            "L2VPN MSTP VLAN Table";
          list mstp-vlan {
            key "vlan-id";
            description
              "L2VPN MSTP VLAN information";
            leaf vlan-id {
              type uint32 {
                range "0..4098";
              }
              description "vlan id";
            }

            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";
              leaf interface-name {
                type string;
                description "Interface name";
              }
            }  // list sub-interface
          }  // list mstp-vlan
        }  // container mstp-vlans

        container l2vpn-pbb-bsa {
          description
            "L2VPN PBB Backbone Source MAC information";
          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";
          }
        }  // container l2vpn-pbb-bsa

        container flexible-xconnect-services {
          description
            "Flexible XConnect Service Table";
          list flexible-xconnect-service {
            key "name";
            description
              "Flexible XConnect Service Information";
            container flexible-xconnect-service-acs {
              description
                "Flexible XConnect Service Attachment Circuit
Table";
              list flexible-xconnect-service-ac {
                key "interface-name";
                description
                  "Flexible XConnect Service Attachment Circuit";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                container attachment-circuit {
                  description
                    "Flexible XConnect Service Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit
              }  // list flexible-xconnect-service-ac
            }  // container flexible-xconnect-service-acs

            container flexible-xconnect-service-info {
              description
                "Flexible XConnect Service Information";
              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";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // list pseudowire
            }  // container flexible-xconnect-service-info

            leaf name {
              type xr:Cisco-ios-xr-string {
                length "1..23";
              }
              description
                "Flexible XConnect Service Name";
            }
          }  // list flexible-xconnect-service
        }  // container flexible-xconnect-services

        container xconnect-brief {
          description
            "XConnect brief information";
          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";
            list ac1 {
              description
                "Array of l2vpn_xc_brief_first layer indexed by
the AC1 encapsulation type";
              list ac2 {
                description
                  "Array of l2vpn_xc_brief_line indexed by the AC2
encapsulation type plus one type for PW";
                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
              }  // list ac2
            }  // list ac1
          }  // list encapsulation-report-matrix

          list encapsulation-total {
            max-elements 4;
            description "Total summary";
            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
          }  // list encapsulation-total
        }  // container xconnect-brief
      }  // container standby

      container active {
        description
          "Active L2VPN operational data";
        container discoveries {
          description "Discovery Table";
          list discovery {
            description
              "VPLS Discovery information";
            leaf service-name {
              type L2vpn-service;
              description "Service type";
            }

            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "Group Name";
            }

            leaf vpn-name {
              type xr:Cisco-ios-xr-string {
                length "1..27";
              }
              description "VPN Name";
            }

            container signalling-info {
              description
                "Info about signalling protocol";
              container bgp-sig-info {
                when
                  "../ad-signalling-method = 'l2vpn-ad-sig-method-bgp'" {
                  description
                    "../ADSignallingMethod =
'L2VPN_AD_SIG_METHOD_BGP'";
                }
                description "bgp sig info";
                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";
                  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";
                    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
                  }  // list label-block
                }  // list edge

                list redge {
                  description
                    "List of edge ids";
                  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";
                    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
                  }  // list label-block
                }  // list redge
              }  // 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";
                container local-vpls-id {
                  description
                    "Local VPLS-ID";
                  container auto {
                    when
                      "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                      description
                        "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                    }
                    description "auto";
                    leaf asn {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf vpn-id {
                      type uint32;
                      description "VPN ID";
                    }
                  }  // 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";
                    leaf two-byte-as {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf four-byte-index {
                      type uint32;
                      description
                        "4 Byte Index";
                    }
                  }  // 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";
                    leaf ipv4-address {
                      type inet:ipv4-address;
                      description
                        "IPv4 Address";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container v4-addr

                  leaf vpls-id-type {
                    type L2vpn-ad-vpls-id;
                    description
                      "VPLS ID TYPE";
                  }
                }  // 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";
                  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";
                  }
                }  // list remote-nlri
              }  // container ldp-sig-info

              leaf ad-signalling-method {
                type L2vpn-ad-sig-method;
                description
                  "ADSignallingMethod";
              }
            }  // 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";
            }
          }  // list discovery
        }  // container discoveries

        container flexible-xconnect-service-summary {
          description
            "Flexible XConnect Service summary information";
          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";
          }
        }  // container flexible-xconnect-service-summary

        container main-interfaces {
          description "Main Interface";
          list main-interface {
            key "interface-name";
            description
              "Main Interface Table";
            container main-interface-instances {
              description
                "Main Interface Instance table";
              list main-interface-instance {
                key "instance";
                description
                  "Main Interface Instance";
                container main-interface-instance-info {
                  description
                    "Main Interface Instance info";
                  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";
                  }
                }  // container main-interface-instance-info

                container main-interface-instance-bridge-ports {
                  description
                    "Main Interface Instance Bridge Port table";
                  list main-interface-instance-bridge-port {
                    key "bridge-port";
                    description
                      "Main Interface Bridge Port info";
                    leaf bridge-port {
                      type xr:Interface-name;
                      description
                        "Bridge Port";
                    }

                    leaf bridge-port-xr {
                      type xr:Interface-name;
                      description
                        "Bridge port ifhandle";
                    }

                    leaf instance-id {
                      type uint32;
                      description
                        "Instance ID";
                    }
                  }  // list main-interface-instance-bridge-port
                }  // container main-interface-instance-bridge-ports

                leaf instance {
                  type Msti-range;
                  description "Instance";
                }
              }  // list main-interface-instance
            }  // container main-interface-instances

            container main-interface-info {
              description
                "Main Interface info";
              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";
              }
            }  // container main-interface-info

            leaf interface-name {
              type xr:Interface-name;
              description "Main interface";
            }
          }  // list main-interface
        }  // container main-interfaces

        container iccp-sm {
          description
            "ICCP-based Service Multi-homing operational data";
          container iccp-sm-summary {
            description
              "ICCP-based Service Multi-homing database
summary";
            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";
            }
          }  // container iccp-sm-summary

          container iccp-groups {
            description "ICCP Group Table";
            list iccp-group {
              key "group-id";
              description "ICCP Group";
              container iccp-group-info {
                description
                  "ICCP Group Information";
                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";
                  container local-port {
                    description
                      "Local port info";
                    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";
                    }
                  }  // container local-port

                  container remote-port {
                    description
                      "Remote port info";
                    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";
                    }
                  }  // 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?";
                  }
                }  // list ports
              }  // container iccp-group-info

              container iccp-ports {
                description
                  "ICCP Port Table";
                list iccp-port {
                  key "interface";
                  description "ICCP Port";
                  leaf interface {
                    type xr:Interface-name;
                    description "Interface";
                  }

                  container local-port {
                    description
                      "Local port info";
                    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";
                    }
                  }  // container local-port

                  container remote-port {
                    description
                      "Remote port info";
                    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";
                    }
                  }  // 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?";
                  }
                }  // list iccp-port
              }  // container iccp-ports

              leaf group-id {
                type uint32 {
                  range "1..4294967295";
                }
                description "Group ID";
              }
            }  // list iccp-group
          }  // container iccp-groups
        }  // container iccp-sm

        container bridge-summary {
          description
            "Bridge Domain summary information";
          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";
          }
        }  // container bridge-summary

        container nsr {
          description
            "L2VPN NSR information";
          container 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";
            }
          }  // container failover-status

          container nsr-status {
            description
              "L2VPN NSR status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // container nsr-status

          container issu-status {
            description
              "L2VPN ISSU Status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // 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";
            leaf app-type {
              type L2vpn-id-mgr-app-bag;
              description "App type";
            }

            leaf sent-ids {
              type uint32;
              description
                "Number of XIDs transferred";
            }
          }  // list xid-info

          list report-card {
            description
              "L2VPN Collaborator 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";
            }
          }  // list report-card
        }  // container nsr

        container preferred-paths {
          description "Preferred path Table";
          list preferred-path {
            description
              "Preferred path information";
            leaf preferred-type {
              type Preferred-path-option;
              description "Preferred type";
            }

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

            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";
              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";
              }
            }  // list virtual-circuit
          }  // list preferred-path
        }  // container preferred-paths

        container pseudowire-headend {
          description
            "Pseudowire Headend related operational data";
          container detail-interfaces {
            description "PW-HE Interfaces";
            list detail-interface {
              key "interface-name";
              description
                "PW-HE Interface detail";
              leaf interface-name {
                type xr:Interface-name;
                description
                  "PWHE Interface name";
              }

              container l2-address {
                description "Layer2 Address";
                container mac-address {
                  when
                    "../interface-type = 'pseudowire-ether'" {
                    description
                      "../InterfaceType = 'PseudowireEther'";
                  }
                  description "MAC address";
                  leaf mac-address {
                    type yang:mac-address;
                    description
                      "MAC Address";
                  }
                }  // container mac-address

                leaf interface-type {
                  type L2vpn-pwhe-intf;
                  description
                    "InterfaceType";
                }
              }  // container l2-address

              container generic-interface-list {
                description
                  "Generic Interface List";
                leaf generic-interface-list-name {
                  type string;
                  description
                    "Generic interface list name";
                }

                leaf id {
                  type uint32;
                  description
                    "Generic interface list ID";
                }

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

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

                  leaf interface-state {
                    type Pwhe-port-im-state;
                    description
                      "Interface Status";
                  }

                  leaf replicate-state {
                    type L2vpn-pwhe-iflist-rep-status;
                    description
                      "Replication status";
                  }

                  leaf misconfigured {
                    type int32;
                    description
                      "Interface misconfigured";
                  }
                }  // list interface-detail
              }  // container generic-interface-list

              leaf interface-state {
                type Pwhe-port-im-state;
                description
                  "Interface Status";
              }

              leaf admin-state {
                type Pwhe-port-im-state;
                description
                  "Interface Admin Status";
              }

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

              leaf bandwidth {
                type uint32;
                units "kbit/s";
                description
                  "Bandwidth (Kbps)";
              }

              leaf label {
                type uint32;
                description "Label";
              }

              leaf l2-overhead {
                type uint32;
                description "L2 Overhead";
              }

              leaf vctype {
                type uint32;
                description "VC Type";
              }

              leaf control-word {
                type int32;
                description "Control Word";
              }
            }  // list detail-interface
          }  // container detail-interfaces

          container summary {
            description
              "PW-HE interface summary";
            leaf interfaces {
              type uint32;
              description
                "Number of PW-HE interfaces";
            }

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

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

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

            leaf psuedowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces";
            }

            leaf up-psuedowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces up";
            }

            leaf down-pseudowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces down";
            }

            leaf admin-down-pseudowire-ether-interfaces {
              type uint32;
              description
                "Number of PW-Ether interfaces admin down";
            }

            leaf pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces";
            }

            leaf up-pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces up";
            }

            leaf down-pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces down";
            }

            leaf admin-down-pseudowire-iw-interfaces {
              type uint32;
              description
                "Number of PW-IW interfaces admin down";
            }
          }  // container summary
        }  // container pseudowire-headend

        container global-settings {
          description
            "L2VPN global settings";
          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";
          }
        }  // container global-settings

        container pwr {
          description
            "Pseudowire Routing Table";
          container summary {
            description
              "L2VPN Pseudowire Routing Summary";
            container rd-auto {
              description
                "Automatic Route Distingtuisher";
              container auto {
                when
                  "../rd = 'l2vpn-ad-rd-auto'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AUTO'";
                }
                description "auto";
                leaf router-id {
                  type inet:ipv4-address;
                  description
                    "BGP Router ID";
                }

                leaf auto-index {
                  type uint16;
                  description
                    "Auto-generated Index";
                }
              }  // container auto

              container two-byte-as {
                when
                  "../rd = 'l2vpn-ad-rd-as'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AS'";
                }
                description "two byte as";
                leaf two-byte-as {
                  type uint16;
                  description
                    "2 Byte AS Number";
                }

                leaf four-byte-index {
                  type uint32;
                  description "4 Byte Index";
                }
              }  // 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";
                leaf four-byte-as {
                  type uint32;
                  description
                    "4 Byte AS Number";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container four-byte-as

              container v4-addr {
                when
                  "../rd = 'l2vpn-ad-rd-v4-addr'" {
                  description
                    "../RD = 'L2VPN_AD_RD_V4ADDR'";
                }
                description "v4 addr";
                leaf ipv4-address {
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container v4-addr

              leaf rd {
                type L2vpn-ad-rd;
                description "RD";
              }
            }  // container rd-auto

            container rd-configured {
              description
                "Configured Route Distinguisher";
              container auto {
                when
                  "../rd = 'l2vpn-ad-rd-auto'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AUTO'";
                }
                description "auto";
                leaf router-id {
                  type inet:ipv4-address;
                  description
                    "BGP Router ID";
                }

                leaf auto-index {
                  type uint16;
                  description
                    "Auto-generated Index";
                }
              }  // container auto

              container two-byte-as {
                when
                  "../rd = 'l2vpn-ad-rd-as'" {
                  description
                    "../RD = 'L2VPN_AD_RD_AS'";
                }
                description "two byte as";
                leaf two-byte-as {
                  type uint16;
                  description
                    "2 Byte AS Number";
                }

                leaf four-byte-index {
                  type uint32;
                  description "4 Byte Index";
                }
              }  // 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";
                leaf four-byte-as {
                  type uint32;
                  description
                    "4 Byte AS Number";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container four-byte-as

              container v4-addr {
                when
                  "../rd = 'l2vpn-ad-rd-v4-addr'" {
                  description
                    "../RD = 'L2VPN_AD_RD_V4ADDR'";
                }
                description "v4 addr";
                leaf ipv4-address {
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf two-byte-index {
                  type uint16;
                  description "2 Byte Index";
                }
              }  // container v4-addr

              leaf rd {
                type L2vpn-ad-rd;
                description "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";
            }
          }  // container summary
        }  // container pwr

        container xconnect-mp2mp-ce2ces {
          description
            "XConnect MP2MP CE2CE Table";
          list xconnect-mp2mp-ce2ce {
            description
              "XConnect MP2MP CE2CE information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

            leaf mp2-mp-name {
              type xr:Cisco-ios-xr-string {
                length "1..26";
              }
              description "Mp2Mp Name";
            }

            leaf local-ceid {
              type uint32 {
                range "1..4294967295";
              }
              description "Local CE ID";
            }

            leaf remote-ceid {
              type uint32 {
                range "1..4294967295";
              }
              description "Remote CE ID";
            }

            container backup {
              description "LCR backup";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container backup

            container segment1 {
              description "Segment 1";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment1

            container segment2 {
              description "Segment 2";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment2

            container ce2ce {
              description "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";
              }
            }  // 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";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // list backup-segment
          }  // list xconnect-mp2mp-ce2ce
        }  // container xconnect-mp2mp-ce2ces

        container xconnects {
          description "XConnect Table";
          list xconnect {
            key "group-name xconnect-name";
            description
              "XConnect information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

            leaf xconnect-name {
              type string {
                length "1..38";
              }
              description "XConnect Name";
            }

            container backup {
              description "LCR backup";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container backup

            container segment1 {
              description "Segment 1";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment1

            container segment2 {
              description "Segment 2";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // container segment2

            container ce2ce {
              description "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";
              }
            }  // 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";
              container attachment-circuit {
                when
                  "../segment-type = 'l2vpn-segment-type-ac'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                }
                description
                  "Attachment Circuit";
                container interface {
                  description "Interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container interface

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container l2vpn-protection {
                  description
                    "Protection object used for this segment";
                  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";
                  }
                }  // 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";
                }
              }  // container attachment-circuit

              container pseudo-wire {
                when
                  "../segment-type = 'l2vpn-segment-type-pw'" {
                  description
                    "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                }
                description "Pseudowire";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // container pseudo-wire

              leaf segment-type {
                type L2vpn-segment;
                description "SegmentType";
              }
            }  // list backup-segment
          }  // list xconnect
        }  // container xconnects

        container xconnect-groups {
          description "XConnect group Table";
          list xconnect-group {
            key "group-name";
            description
              "XConnect group information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

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

            leaf number-xconnects {
              type uint32;
              description
                "Number of xconnects";
            }
          }  // list xconnect-group
        }  // container xconnect-groups

        container xconnect-mp2mps {
          description "XConnect MP2MP Table";
          list xconnect-mp2mp {
            key "group-name mp2-mp-name";
            description
              "XConnect MP2MP information";
            leaf group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description "XConnect Group";
            }

            leaf mp2-mp-name {
              type xr:Cisco-ios-xr-string {
                length "1..26";
              }
              description "Mp2Mp Name";
            }

            container discovery {
              description
                "l2vpn xc auto discovery info";
              container rd-value {
                description
                  "Route Distinguisher";
                container auto {
                  when
                    "../rd = 'l2vpn-ad-rd-auto'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AUTO'";
                  }
                  description "auto";
                  leaf router-id {
                    type inet:ipv4-address;
                    description
                      "BGP Router ID";
                  }

                  leaf auto-index {
                    type uint16;
                    description
                      "Auto-generated Index";
                  }
                }  // container auto

                container two-byte-as {
                  when
                    "../rd = 'l2vpn-ad-rd-as'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rd = 'l2vpn-ad-rd-v4-addr'" {
                    description
                      "../RD = 'L2VPN_AD_RD_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                leaf rd {
                  type L2vpn-ad-rd;
                  description "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";
                container two-byte-as {
                  when
                    "../rt = 'l2vpn-ad-rt-as'" {
                    description
                      "../RT = 'L2VPN_AD_RT_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rt = 'l2vpn-ad-rt-v4-addr'" {
                    description
                      "../RT = 'L2VPN_AD_RT_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                container es-import {
                  when "../rt = 'es-import'" {
                    description
                      "../RT = 'ES_Import'";
                  }
                  description "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";
                  }
                }  // container es-import

                leaf rt {
                  type L2vpn-ad-rt;
                  description "RT";
                }
              }  // list import-rt

              list export-rt {
                description
                  "Export Route Targets";
                container two-byte-as {
                  when
                    "../rt = 'l2vpn-ad-rt-as'" {
                    description
                      "../RT = 'L2VPN_AD_RT_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rt = 'l2vpn-ad-rt-v4-addr'" {
                    description
                      "../RT = 'L2VPN_AD_RT_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                container es-import {
                  when "../rt = 'es-import'" {
                    description
                      "../RT = 'ES_Import'";
                  }
                  description "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";
                  }
                }  // container es-import

                leaf rt {
                  type L2vpn-ad-rt;
                  description "RT";
                }
              }  // list export-rt
            }  // 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";
            }
          }  // list xconnect-mp2mp
        }  // container xconnect-mp2mps

        container srte-policies {
          description "SRTE Policy Table";
          list srte-policy {
            description
              "SRTE Policy information";
            leaf color {
              type uint32;
              description "Policy Color";
            }

            leaf endpoint {
              type inet:ip-address-no-zone;
              description
                "Policy Endpoint IP Address";
            }

            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";
            }
          }  // list srte-policy
        }  // container srte-policies

        container indexes {
          description
            "ID Manager Index Table";
          list index {
            key "pool-id";
            description
              "ID Manager Index Pool";
            leaf pool-id {
              type xr:Hex-integer;
              description "Pool ID";
            }

            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";
            }
          }  // list index
        }  // container indexes

        container xconnect-summary {
          description
            "XConnect summary information";
          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";
          }
        }  // container xconnect-summary

        container proc-fsm {
          description
            "L2VPN Process FSM information";
          container 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";
            }
          }  // container failover-status

          container nsr-status {
            description
              "L2VPN NSR status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // container nsr-status

          container issu-status {
            description
              "L2VPN ISSU Status and timestamp";
            container idt-status {
              description "IDT status";
              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";
              }
            }  // container idt-status

            container previ-ous-idt-status {
              description
                "Previous IDT status";
              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";
              }
            }  // container previ-ous-idt-status

            leaf nsr-role {
              type uint8;
              description "NSR role";
            }

            leaf issu-role {
              type uint8;
              description "ISSU role";
            }
          }  // 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";
            leaf app-type {
              type L2vpn-id-mgr-app-bag;
              description "App type";
            }

            leaf sent-ids {
              type uint32;
              description
                "Number of XIDs transferred";
            }
          }  // list xid-info

          list report-card {
            description
              "L2VPN Collaborator 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";
            }
          }  // list report-card
        }  // container proc-fsm

        container mstp-ports {
          description
            "L2VPN MSTP Port Table";
          list mstp-port {
            key "interface";
            description
              "MSTP Port information";
            leaf interface {
              type xr:Interface-name;
              description "Interface";
            }

            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";
              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";
                leaf bdid {
                  type uint32;
                  description "BD ID";
                }

                leaf bdif-count {
                  type uint32;
                  description
                    "BD Intf Count";
                }
              }  // list bd-entry
            }  // list msti-entry
          }  // list mstp-port
        }  // container mstp-ports

        container generic-interface-list-details {
          description
            "L2VPN generic interface list Detail Table";
          list generic-interface-list-detail {
            key "interface-list-name";
            description
              "Generic Interface List detail information";
            leaf interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Generic Interface List Name";
            }

            container summary {
              description
                "Summary information";
              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";
                leaf interface-name {
                  type string;
                  description
                    "Interface name";
                }

                leaf pending-replications {
                  type uint32;
                  description
                    "Number of pending replications";
                }

                leaf not-supported-replications {
                  type uint32;
                  description
                    "Number of replications failed because
unsupported";
                }

                leaf is-fib-downloaded {
                  type boolean;
                  description
                    "Is interface downloaded to FIB";
                }
              }  // list interface
            }  // 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";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf pending-replications {
                type uint32;
                description
                  "Number of pending replications";
              }

              leaf not-supported-replications {
                type uint32;
                description
                  "Number of replications failed because
unsupported";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is interface downloaded to FIB";
              }
            }  // list interface

            list pseudowire-ether-range {
              description "PW-Ether ranges";
              leaf lower {
                type uint16;
                description "lower range";
              }

              leaf upper {
                type uint16;
                description "upper range";
              }
            }  // list pseudowire-ether-range

            list pseudowire-iw-range {
              description "PW-IW ranges";
              leaf lower {
                type uint16;
                description "lower range";
              }

              leaf upper {
                type uint16;
                description "upper range";
              }
            }  // list pseudowire-iw-range
          }  // list generic-interface-list-detail
        }  // container generic-interface-list-details

        container l2vpn-resource-state {
          description
            "L2VPN resource state information";
          leaf resource-out-of-memory-state {
            type uint32;
            description
              "L2VPN Out of memory state";
          }
        }  // container l2vpn-resource-state

        container bridge-domains {
          description
            "Bridge Domain Information";
          list bridge-domain {
            key "bridge-domain-group-name bridge-domain-name";
            description
              "Bridge Domain Information";
            container bridge-access-vfi-table {
              description
                "Bridge Domain Access VFI Table";
              container bridge-pws {
                description
                  "Bridge Domain Access/Core Pseudowire Table";
                list bridge-pw {
                  description
                    "Bridge Domain Pseudowire";
                  leaf neighbor {
                    type inet:ipv4-address-no-zone;
                    description
                      "Neighbor IPv4 address";
                  }

                  leaf pw-type {
                    type L2vpnpw;
                    description "PW Type";
                  }

                  leaf pseudowire-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Pseudowire ID";
                  }

                  leaf ve-id-vpls-id-0-3 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                  }

                  leaf vpls-id-4-7 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or Last 4 bytes of VPLS-ID";
                  }

                  container pseudowire {
                    description "Pseudowire";
                    container peer-id {
                      description "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";
                      }
                    }  // container peer-id

                    container encapsulation-info {
                      description
                        "Encapsulation specific pseudowire information";
                      container atom {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                        }
                        description "atom";
                        container local-agi {
                          description
                            "Local Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container local-agi

                        container remote-agi {
                          description
                            "Remote Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container remote-agi

                        container multi-segment-pseudowire-stats {
                          description
                            "Multisegment pseudowire statistics";
                          leaf received-packets {
                            type uint64;
                            description
                              "Packets received";
                          }

                          leaf received-bytes {
                            type uint64;
                            units "byte";
                            description
                              "Bytes received";
                          }
                        }  // 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";
                        }
                      }  // container atom

                      container l2tpv3 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                        }
                        description "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";
                        }
                      }  // container l2tpv3

                      container srv6 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                        }
                        description "srv6";
                        container srv6-headend-behavior {
                          description
                            "Headend behavior in use";
                          leaf type {
                            type Mgmt-srv6-headend;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // container srv6-headend-behavior

                        container srv6-endpoint-behavior {
                          description
                            "Endpoint behavior in use";
                          leaf type {
                            type Mgmt-srv6-endpoint;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // 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";
                          container sr-te-info {
                            description
                              "SR(v6)-TE Policy info from ODN";
                            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";
                            }
                          }  // container sr-te-info

                          container layer2-attributes {
                            description
                              "Layer 2 Attributes";
                            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";
                            }
                          }  // 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";
                            leaf srv6-sid {
                              type inet:ipv6-address;
                              description
                                "SRv6 SID";
                            }
                          }  // list srv6-sid-info
                        }  // list remote-path-buffer
                      }  // container srv6

                      leaf encapsulation {
                        type L2vpn-encap-method;
                        description
                          "Encapsulation";
                      }
                    }  // container encapsulation-info

                    container local-interface {
                      description
                        "Local interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container local-interface

                    container remote-interface {
                      description
                        "Remote interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container remote-interface

                    container preferred-path {
                      description
                        "MPLS Preferred Path";
                      container srte-policy {
                        when
                          "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                          description
                            "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                        }
                        description
                          "srte policy";
                        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";
                        }
                      }  // 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";
                        leaf te-named-tunnel {
                          type string;
                          description
                            "TE Tunnel Name";
                        }
                      }  // 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";
                      }
                    }  // container preferred-path

                    container local-signalling {
                      description
                        "Local signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container local-signalling

                    container remote-signalling {
                      description
                        "Remote signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container remote-signalling

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container p2mp-pw {
                      description
                        "P2MP Pseudowire Information";
                      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)";
                      }
                    }  // 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
                  }  // container pseudowire

                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

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

                  list static-mac {
                    description
                      "Static MAC addresses";
                    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";
                    }
                  }  // list static-mac
                }  // list bridge-pw
              }  // container bridge-pws
            }  // container bridge-access-vfi-table

            container bridge-core-vfi-table {
              description
                "Bridge Domain Core VFI Table";
              container bridge-pws {
                description
                  "Bridge Domain Access/Core Pseudowire Table";
                list bridge-pw {
                  description
                    "Bridge Domain Pseudowire";
                  leaf neighbor {
                    type inet:ipv4-address-no-zone;
                    description
                      "Neighbor IPv4 address";
                  }

                  leaf pw-type {
                    type L2vpnpw;
                    description "PW Type";
                  }

                  leaf pseudowire-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Pseudowire ID";
                  }

                  leaf ve-id-vpls-id-0-3 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                  }

                  leaf vpls-id-4-7 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or Last 4 bytes of VPLS-ID";
                  }

                  container pseudowire {
                    description "Pseudowire";
                    container peer-id {
                      description "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";
                      }
                    }  // container peer-id

                    container encapsulation-info {
                      description
                        "Encapsulation specific pseudowire information";
                      container atom {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                        }
                        description "atom";
                        container local-agi {
                          description
                            "Local Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container local-agi

                        container remote-agi {
                          description
                            "Remote Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container remote-agi

                        container multi-segment-pseudowire-stats {
                          description
                            "Multisegment pseudowire statistics";
                          leaf received-packets {
                            type uint64;
                            description
                              "Packets received";
                          }

                          leaf received-bytes {
                            type uint64;
                            units "byte";
                            description
                              "Bytes received";
                          }
                        }  // 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";
                        }
                      }  // container atom

                      container l2tpv3 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                        }
                        description "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";
                        }
                      }  // container l2tpv3

                      container srv6 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                        }
                        description "srv6";
                        container srv6-headend-behavior {
                          description
                            "Headend behavior in use";
                          leaf type {
                            type Mgmt-srv6-headend;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // container srv6-headend-behavior

                        container srv6-endpoint-behavior {
                          description
                            "Endpoint behavior in use";
                          leaf type {
                            type Mgmt-srv6-endpoint;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // 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";
                          container sr-te-info {
                            description
                              "SR(v6)-TE Policy info from ODN";
                            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";
                            }
                          }  // container sr-te-info

                          container layer2-attributes {
                            description
                              "Layer 2 Attributes";
                            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";
                            }
                          }  // 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";
                            leaf srv6-sid {
                              type inet:ipv6-address;
                              description
                                "SRv6 SID";
                            }
                          }  // list srv6-sid-info
                        }  // list remote-path-buffer
                      }  // container srv6

                      leaf encapsulation {
                        type L2vpn-encap-method;
                        description
                          "Encapsulation";
                      }
                    }  // container encapsulation-info

                    container local-interface {
                      description
                        "Local interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container local-interface

                    container remote-interface {
                      description
                        "Remote interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

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

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

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

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container remote-interface

                    container preferred-path {
                      description
                        "MPLS Preferred Path";
                      container srte-policy {
                        when
                          "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                          description
                            "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                        }
                        description
                          "srte policy";
                        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";
                        }
                      }  // 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";
                        leaf te-named-tunnel {
                          type string;
                          description
                            "TE Tunnel Name";
                        }
                      }  // 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";
                      }
                    }  // container preferred-path

                    container local-signalling {
                      description
                        "Local signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container local-signalling

                    container remote-signalling {
                      description
                        "Remote signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

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

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container remote-signalling

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container p2mp-pw {
                      description
                        "P2MP Pseudowire Information";
                      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)";
                      }
                    }  // 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
                  }  // container pseudowire

                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

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

                  list static-mac {
                    description
                      "Static MAC addresses";
                    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";
                    }
                  }  // list static-mac
                }  // list bridge-pw
              }  // container bridge-pws
            }  // container bridge-core-vfi-table

            container bridge-acs {
              description
                "Bridge Domain Attachment Circuit Table";
              list bridge-ac {
                key "interface-name";
                description
                  "Bridge Domain Attachment Circuit";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                container attachment-circuit {
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container security-parameters {
                  description
                    "Security Parameters";
                  container base {
                    description
                      "Basic Security Parameters";
                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container base

                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

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

                list static-mac {
                  description
                    "Static MAC addresses";
                  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";
                  }
                }  // list static-mac

                list bvimac {
                  description
                    "BVI MAC addresses";
                  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";
                  }
                }  // list bvimac
              }  // list bridge-ac
            }  // container bridge-acs

            container bridge-access-pws {
              description
                "Bridge Domain Access Pseudowire Table";
              list bridge-access-pw {
                description
                  "Bridge Domain Access Pseudowire";
                leaf neighbor {
                  type inet:ipv4-address-no-zone;
                  description
                    "Neighbor IPv4 address";
                }

                leaf pw-type {
                  type L2vpnpw;
                  description "PW Type";
                }

                leaf pseudowire-id {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description
                    "Pseudowire ID";
                }

                leaf ve-id-vpls-id-0-3 {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                }

                leaf vpls-id-4-7 {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "Zero or Last 4 bytes of VPLS-ID";
                }

                container pseudowire {
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudowire

                container security-parameters {
                  description
                    "Security Parameters";
                  container base {
                    description
                      "Basic Security Parameters";
                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container base

                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

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

                list static-mac {
                  description
                    "Static MAC addresses";
                  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";
                  }
                }  // list static-mac
              }  // list bridge-access-pw
            }  // container bridge-access-pws

            container bridge-domain-info {
              description
                "Bridge Domain Information";
              container security-parameters {
                description
                  "Security parameters";
                container storm-control {
                  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";
                  }
                }  // 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";
                }
              }  // container security-parameters

              container pbb-parameters {
                description "PBB parameters";
                container pbb-edge {
                  when
                    "../type = 'l2vpn-bridge-type-pbb-edge'" {
                    description
                      "../Type = 'L2VPN_BRIDGE_TYPE_PBB_EDGE'";
                  }
                  description "PBB Edge";
                  container edge-port {
                    description
                      "PBB Edge Port";
                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container security-parameters

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // 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";
                      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";
                      }
                    }  // list bmac-mapping
                  }  // 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";
                  }
                }  // container pbb-edge

                container pbb-core {
                  when
                    "../type = 'l2vpn-bridge-type-pbb-core'" {
                    description
                      "../Type = 'L2VPN_BRIDGE_TYPE_PBB_CORE'";
                  }
                  description "PBB Core";
                  container core-port {
                    description
                      "PBB Core Port";
                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // 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";
                    }
                  }  // container core-port

                  leaf num-ass-edge {
                    type uint32;
                    description
                      "Number of Associated PBB Edges";
                  }
                }  // container pbb-core

                leaf type {
                  type L2vpn-bridge;
                  description "Type";
                }
              }  // container pbb-parameters

              container evpn-parameters {
                description
                  "EVPN parameters";
                container evpn-port {
                  description "EVPN Port";
                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

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

                  leaf evpn-port-state {
                    type L2vpn-virtualport-state;
                    description
                      "EVPN Port State";
                  }
                }  // container evpn-port

                leaf evi {
                  type uint32;
                  description "E-VPN id";
                }
              }  // container evpn-parameters

              container vni-parameters {
                description "VNI parameters";
                container security-parameters {
                  description
                    "Security Parameters";
                  container base {
                    description
                      "Basic Security Parameters";
                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container base

                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // 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";
                  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";
                  }
                }  // list static-mac
              }  // container vni-parameters

              container rd {
                description
                  "Route Distinguisher";
                container auto {
                  when
                    "../rd = 'l2vpn-ad-rd-auto'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AUTO'";
                  }
                  description "auto";
                  leaf router-id {
                    type inet:ipv4-address;
                    description
                      "BGP Router ID";
                  }

                  leaf auto-index {
                    type uint16;
                    description
                      "Auto-generated Index";
                  }
                }  // container auto

                container two-byte-as {
                  when
                    "../rd = 'l2vpn-ad-rd-as'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rd = 'l2vpn-ad-rd-v4-addr'" {
                    description
                      "../RD = 'L2VPN_AD_RD_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                leaf rd {
                  type L2vpn-ad-rd;
                  description "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";
                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";
                }
              }  // list mac-filter

              list bridge-vfi {
                description
                  "Virtual Forwarding Interfaces";
                container discovery-information {
                  description
                    "Auto Discovery information";
                  container rd-value {
                    description
                      "Route Distinguisher";
                    container auto {
                      when
                        "../rd = 'l2vpn-ad-rd-auto'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AUTO'";
                      }
                      description "auto";
                      leaf router-id {
                        type inet:ipv4-address;
                        description
                          "BGP Router ID";
                      }

                      leaf auto-index {
                        type uint16;
                        description
                          "Auto-generated Index";
                      }
                    }  // container auto

                    container two-byte-as {
                      when
                        "../rd = 'l2vpn-ad-rd-as'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rd = 'l2vpn-ad-rd-v4-addr'" {
                        description
                          "../RD = 'L2VPN_AD_RD_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf rd {
                      type L2vpn-ad-rd;
                      description "RD";
                    }
                  }  // container rd-value

                  container vpls-id {
                    description "VPLS ID";
                    container auto {
                      when
                        "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                        description
                          "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                      }
                      description "auto";
                      leaf asn {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf vpn-id {
                        type uint32;
                        description "VPN ID";
                      }
                    }  // 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";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf vpls-id-type {
                      type L2vpn-ad-vpls-id;
                      description
                        "VPLS ID TYPE";
                    }
                  }  // 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";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list import-rt

                  list export-rt {
                    description
                      "List of export route targets";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list export-rt
                }  // 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";
                  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";
                  }
                }  // list p2mp-information
              }  // list bridge-vfi

              list bridge-access-vfi {
                description
                  "Access Virtual Forwarding Interfaces";
                container discovery-information {
                  description
                    "Auto Discovery information";
                  container rd-value {
                    description
                      "Route Distinguisher";
                    container auto {
                      when
                        "../rd = 'l2vpn-ad-rd-auto'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AUTO'";
                      }
                      description "auto";
                      leaf router-id {
                        type inet:ipv4-address;
                        description
                          "BGP Router ID";
                      }

                      leaf auto-index {
                        type uint16;
                        description
                          "Auto-generated Index";
                      }
                    }  // container auto

                    container two-byte-as {
                      when
                        "../rd = 'l2vpn-ad-rd-as'" {
                        description
                          "../RD = 'L2VPN_AD_RD_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rd = 'l2vpn-ad-rd-v4-addr'" {
                        description
                          "../RD = 'L2VPN_AD_RD_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf rd {
                      type L2vpn-ad-rd;
                      description "RD";
                    }
                  }  // container rd-value

                  container vpls-id {
                    description "VPLS ID";
                    container auto {
                      when
                        "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                        description
                          "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                      }
                      description "auto";
                      leaf asn {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf vpn-id {
                        type uint32;
                        description "VPN ID";
                      }
                    }  // 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";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf vpls-id-type {
                      type L2vpn-ad-vpls-id;
                      description
                        "VPLS ID TYPE";
                    }
                  }  // 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";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list import-rt

                  list export-rt {
                    description
                      "List of export route targets";
                    container two-byte-as {
                      when
                        "../rt = 'l2vpn-ad-rt-as'" {
                        description
                          "../RT = 'L2VPN_AD_RT_AS'";
                      }
                      description
                        "two byte as";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf four-byte-as {
                        type uint32;
                        description
                          "4 Byte AS Number";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container four-byte-as

                    container v4-addr {
                      when
                        "../rt = 'l2vpn-ad-rt-v4-addr'" {
                        description
                          "../RT = 'L2VPN_AD_RT_V4ADDR'";
                      }
                      description "v4 addr";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    container es-import {
                      when
                        "../rt = 'es-import'" {
                        description
                          "../RT = 'ES_Import'";
                      }
                      description
                        "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";
                      }
                    }  // container es-import

                    leaf rt {
                      type L2vpn-ad-rt;
                      description "RT";
                    }
                  }  // list export-rt
                }  // 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";
                  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";
                  }
                }  // list p2mp-information
              }  // list bridge-access-vfi
            }  // container bridge-domain-info

            leaf bridge-domain-group-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Bridge Domain Group Name";
            }

            leaf bridge-domain-name {
              type xr:Cisco-ios-xr-string {
                length "1..27";
              }
              description
                "Bridge Domain Name";
            }
          }  // list bridge-domain
        }  // container bridge-domains

        container discovery-summary {
          description
            "Discovery summary information";
          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";
          }
        }  // container discovery-summary

        container g8032 {
          description "G8032 information";
          container g8032-rings {
            description "G8032 Ring table";
            list g8032-ring {
              key "ring-name";
              description "G8032 Ring";
              container g8032-ring-detail {
                description
                  "G8032 Ring detailed information";
                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
              }  // container g8032-ring-detail

              container g8032-ring-instance-summaries {
                description
                  "G8032 Ring Instance summary table";
                list g8032-ring-instance-summary {
                  key "instance";
                  description
                    "G8032 Ring Instance summary information";
                  leaf instance {
                    type uint32;
                    description "Instance";
                  }

                  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
                }  // list g8032-ring-instance-summary
              }  // container g8032-ring-instance-summaries

              container g8032-ring-summary {
                description
                  "G8032 Ring summary information";
                leaf ring-name {
                  type string;
                  description
                    "Name of the ring";
                }

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

                leaf port1 {
                  type string;
                  description "Port 1";
                }
              }  // container g8032-ring-summary

              container g8032-ring-instance-details {
                description
                  "G8032 Ring Instance detail table";
                list g8032-ring-instance-detail {
                  key "instance";
                  description
                    "G8032 Ring Instance detailed information";
                  leaf instance {
                    type G8032-ring-instance-range;
                    description "Instance";
                  }

                  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
                }  // list g8032-ring-instance-detail
              }  // container g8032-ring-instance-details

              leaf ring-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "Ring Name";
              }
            }  // list g8032-ring
          }  // container g8032-rings
        }  // container g8032

        container pseudowire-classes {
          description
            "List of pseudowire classes";
          list pseudowire-class {
            key "pseudowire-class-name";
            description
              "Pseudowire class information";
            leaf pseudowire-class-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Pseudowire Class Name";
            }

            container encapsulation-info {
              description
                "Encapsulation specific pseudowire information";
              container l2tpv3 {
                when
                  "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                  description
                    "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                }
                description "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 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";
                }
              }  // container l2tpv3

              leaf encapsulation {
                type L2vpn-encap-method;
                description "Encapsulation";
              }
            }  // container encapsulation-info

            container preferred-path {
              description
                "MPLS Preferred Path";
              container srte-policy {
                when
                  "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                  description
                    "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                }
                description "srte policy";
                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";
                }
              }  // 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";
                leaf te-named-tunnel {
                  type string;
                  description
                    "TE Tunnel Name";
                }
              }  // 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";
              }
            }  // container preferred-path

            container local-source-address {
              description
                "Local 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";
              }
            }  // 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";
            }
          }  // list pseudowire-class
        }  // container pseudowire-classes

        container l2vpn-collaborators {
          description
            "L2VPN collaborator information";
          container collaborator-statistics {
            description
              "Collaborator Statistics";
            list count {
              max-elements 1;
              description "count";
              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";
              }
            }  // list count
          }  // container collaborator-statistics
        }  // container l2vpn-collaborators

        container mvrp {
          description "MVRP";
          container mvrp-main-ports {
            description
              "MVRP Main Port Table";
            list mvrp-main-port {
              key "main-port-interface-name";
              description "MVRP Main Port";
              container mvrp-main-port-info {
                description
                  "MVRP Main Port Information";
                container default-bridge-port {
                  description
                    "Trunk or default Bridge Port";
                  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";
                    leaf lower {
                      type uint16;
                      description "Lower";
                    }

                    leaf upper {
                      type uint16;
                      description "Upper";
                    }
                  }  // list vlan-range
                }  // 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";
                }
              }  // container mvrp-main-port-info

              container mvrp-bridge-ports {
                description
                  "MVRP Bridge Port Table";
                list mvrp-bridge-port {
                  key "interface-name";
                  description
                    "MVRP Bridge Port Information";
                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Bridge Port Interface Name";
                  }

                  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";
                    leaf lower {
                      type uint16;
                      description "Lower";
                    }

                    leaf upper {
                      type uint16;
                      description "Upper";
                    }
                  }  // list vlan-range
                }  // list mvrp-bridge-port
              }  // container mvrp-bridge-ports

              leaf main-port-interface-name {
                type xr:Interface-name;
                description
                  "Main Port interface";
              }
            }  // list mvrp-main-port
          }  // container mvrp-main-ports
        }  // container mvrp

        container generic-interface-lists {
          description
            "L2VPN generic interface list Table";
          list generic-interface-list {
            key "interface-list-name";
            description
              "Generic Interface List information";
            leaf interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Generic Interface List Name";
            }

            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";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf pending-replications {
                type uint32;
                description
                  "Number of pending replications";
              }

              leaf not-supported-replications {
                type uint32;
                description
                  "Number of replications failed because
unsupported";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is interface downloaded to FIB";
              }
            }  // list interface
          }  // list generic-interface-list
        }  // container generic-interface-lists

        container mstp-vlans {
          description
            "L2VPN MSTP VLAN Table";
          list mstp-vlan {
            key "vlan-id";
            description
              "L2VPN MSTP VLAN information";
            leaf vlan-id {
              type uint32 {
                range "0..4098";
              }
              description "vlan id";
            }

            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";
              leaf interface-name {
                type string;
                description "Interface name";
              }
            }  // list sub-interface
          }  // list mstp-vlan
        }  // container mstp-vlans

        container l2vpn-pbb-bsa {
          description
            "L2VPN PBB Backbone Source MAC information";
          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";
          }
        }  // container l2vpn-pbb-bsa

        container flexible-xconnect-services {
          description
            "Flexible XConnect Service Table";
          list flexible-xconnect-service {
            key "name";
            description
              "Flexible XConnect Service Information";
            container flexible-xconnect-service-acs {
              description
                "Flexible XConnect Service Attachment Circuit
Table";
              list flexible-xconnect-service-ac {
                key "interface-name";
                description
                  "Flexible XConnect Service Attachment Circuit";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Interface Name";
                }

                container attachment-circuit {
                  description
                    "Flexible XConnect Service Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit
              }  // list flexible-xconnect-service-ac
            }  // container flexible-xconnect-service-acs

            container flexible-xconnect-service-info {
              description
                "Flexible XConnect Service Information";
              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";
                container peer-id {
                  description "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";
                  }
                }  // container peer-id

                container encapsulation-info {
                  description
                    "Encapsulation specific pseudowire information";
                  container atom {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                    }
                    description "atom";
                    container local-agi {
                      description
                        "Local Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container local-agi

                    container remote-agi {
                      description
                        "Remote Attachment Group Identifier";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // container remote-agi

                    container multi-segment-pseudowire-stats {
                      description
                        "Multisegment pseudowire statistics";
                      leaf received-packets {
                        type uint64;
                        description
                          "Packets received";
                      }

                      leaf received-bytes {
                        type uint64;
                        units "byte";
                        description
                          "Bytes received";
                      }
                    }  // 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";
                    }
                  }  // container atom

                  container l2tpv3 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                    }
                    description "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";
                    }
                  }  // container l2tpv3

                  container srv6 {
                    when
                      "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                      description
                        "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                    }
                    description "srv6";
                    container srv6-headend-behavior {
                      description
                        "Headend behavior in use";
                      leaf type {
                        type Mgmt-srv6-headend;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // container srv6-headend-behavior

                    container srv6-endpoint-behavior {
                      description
                        "Endpoint behavior in use";
                      leaf type {
                        type Mgmt-srv6-endpoint;
                        description
                          "Behavior type";
                      }

                      leaf description {
                        type string;
                        description
                          "Behavior description";
                      }
                    }  // 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";
                      container sr-te-info {
                        description
                          "SR(v6)-TE Policy info from ODN";
                        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";
                        }
                      }  // container sr-te-info

                      container layer2-attributes {
                        description
                          "Layer 2 Attributes";
                        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";
                        }
                      }  // 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";
                        leaf srv6-sid {
                          type inet:ipv6-address;
                          description
                            "SRv6 SID";
                        }
                      }  // list srv6-sid-info
                    }  // list remote-path-buffer
                  }  // container srv6

                  leaf encapsulation {
                    type L2vpn-encap-method;
                    description
                      "Encapsulation";
                  }
                }  // container encapsulation-info

                container local-interface {
                  description
                    "Local interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container local-interface

                container remote-interface {
                  description
                    "Remote interface";
                  container parameters {
                    description
                      "Interface parameters";
                    container ethernet {
                      when
                        "../type = 'l2vpn-intf-type-ethernet'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                      }
                      description "Ethernet";
                      leaf xconnect-tags {
                        type uint8;
                        description
                          "XConnect tags";
                      }
                    }  // container ethernet

                    container vlan {
                      when
                        "../type = 'l2vpn-intf-type-vlan'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                      }
                      description "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";
                        leaf lower {
                          type uint16;
                          description
                            "Lower";
                        }

                        leaf upper {
                          type uint16;
                          description
                            "Upper";
                        }
                      }  // list vlan-range
                    }  // container vlan

                    container tdm {
                      when
                        "../type = 'l2vpn-intf-type-cem'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_CEM'";
                      }
                      description "TDM";
                      container tdm-options {
                        description
                          "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";
                        }
                      }  // 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";
                      }
                    }  // container tdm

                    container atm {
                      when
                        "../type = 'l2vpn-intf-type-atm'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_ATM'";
                      }
                      description "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";
                      }
                    }  // container atm

                    container fr {
                      when
                        "../type = 'l2vpn-intf-type-frame-relay'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                      }
                      description
                        "Frame Relay";
                      leaf fr-mode {
                        type L2vpn-fr-mode;
                        description
                          "Frame Relay mode";
                      }

                      leaf dlci {
                        type uint32;
                        description
                          "Data-link connection identifier";
                      }
                    }  // container fr

                    container pseudowire-ether {
                      when
                        "../type = 'l2vpn-intf-type-pw-ether'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                      }
                      description "PW Ether";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-ether

                    container pseudowire-iw {
                      when
                        "../type = 'l2vpn-intf-type-pw-iw'" {
                        description
                          "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                      }
                      description "PW IW";
                      container interface-list {
                        description
                          "Interface list data";
                        leaf interface-list-name {
                          type string {
                            length "0..33";
                          }
                          description
                            "Interface-list name";
                        }

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

                        list interface {
                          max-elements 32;
                          description
                            "Interfaces";
                          leaf interface-name {
                            type string;
                            description
                              "Interface name";
                          }

                          leaf replicate-status {
                            type Iflist-rep-status;
                            description
                              "Replicate status";
                          }
                        }  // list interface
                      }  // container interface-list

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

                      leaf internal-label {
                        type uint32;
                        description
                          "Internal Label";
                      }
                    }  // container pseudowire-iw

                    leaf type {
                      type L2vpn-interface;
                      description "Type";
                    }
                  }  // 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";
                  }
                }  // container remote-interface

                container preferred-path {
                  description
                    "MPLS Preferred Path";
                  container srte-policy {
                    when
                      "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                      description
                        "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                    }
                    description
                      "srte policy";
                    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";
                    }
                  }  // 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";
                    leaf te-named-tunnel {
                      type string;
                      description
                        "TE Tunnel Name";
                    }
                  }  // 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";
                  }
                }  // container preferred-path

                container local-signalling {
                  description
                    "Local signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container local-signalling

                container remote-signalling {
                  description
                    "Remote signalling";
                  container status-tlv {
                    description
                      "PW Status Switching TLV";
                    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";
                    }
                  }  // container status-tlv

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

                  list tlv {
                    description
                      "Switching 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";
                    }
                  }  // list tlv
                }  // container remote-signalling

                container statistics {
                  description "Statistics";
                  container imposition-stats {
                    description
                      "imposition stats";
                    container imposition-stat {
                      description
                        "imposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-stat

                    container imposition-mtu-drop {
                      description
                        "imposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-mtu-drop

                    container imposition-tail-drop {
                      description
                        "imposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container imposition-tail-drop

                    container l2fsbi-drop {
                      description
                        "rx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container l2fsbi-drop

                    container multicast {
                      description
                        "Multicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast

                    container broadcast {
                      description
                        "Broadcast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container unknown-unicast {
                      description
                        "Unknown Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unknown-unicast
                  }  // container imposition-stats

                  container disposition-stats {
                    description
                      "disposition stats";
                    container disposition-stat {
                      description
                        "disposition stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-stat

                    container disposition-mtu-drop {
                      description
                        "disposition mtu drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-mtu-drop

                    container disposition-tail-drop {
                      description
                        "disposition tail drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-tail-drop

                    container multicast-drop {
                      description
                        "disposition storm control multicast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container multicast-drop

                    container unicast-drop {
                      description
                        "disposition storm control unknown unicast drop
stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container unicast-drop

                    container broadcast-drop {
                      description
                        "disposition storm control broadcast drop stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container broadcast-drop

                    container received-drops {
                      description
                        "tx discards";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container received-drops

                    container dai-drop {
                      description
                        "Disposition dynamic ARP inspection drop
statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container dai-drop

                    container ipsg-drop {
                      description
                        "disposition IP source guard drop statistics";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container ipsg-drop

                    container disposition-oo-o-drops {
                      description
                        "Disposition Out-of-Order Drops";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-oo-o-drops

                    container disposition-p2mp-stats {
                      description
                        "Disposition P2MP Stats";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container disposition-p2mp-stats

                    container known-unicast {
                      description
                        "Known Unicast";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container known-unicast

                    container mac-move {
                      description "MAC Move";
                      leaf packet-counts {
                        type uint64;
                        description
                          "packets counters";
                      }

                      leaf byte-counts {
                        type uint64;
                        units "byte";
                        description
                          "bytes counters";
                      }
                    }  // container mac-move
                  }  // container disposition-stats

                  container sequence-number {
                    description
                      "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";
                    }
                  }  // container sequence-number
                }  // container statistics

                container p2mp-pw {
                  description
                    "P2MP Pseudowire Information";
                  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)";
                  }
                }  // 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
              }  // list pseudowire
            }  // container flexible-xconnect-service-info

            leaf name {
              type xr:Cisco-ios-xr-string {
                length "1..23";
              }
              description
                "Flexible XConnect Service Name";
            }
          }  // list flexible-xconnect-service
        }  // container flexible-xconnect-services

        container xconnect-brief {
          description
            "XConnect brief information";
          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";
            list ac1 {
              description
                "Array of l2vpn_xc_brief_first layer indexed by
the AC1 encapsulation type";
              list ac2 {
                description
                  "Array of l2vpn_xc_brief_line indexed by the AC2
encapsulation type plus one type for PW";
                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
              }  // list ac2
            }  // list ac1
          }  // list encapsulation-report-matrix

          list encapsulation-total {
            max-elements 4;
            description "Total summary";
            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
          }  // list encapsulation-total
        }  // container xconnect-brief
      }  // container active

      container nodes {
        description
          "Table of L2VPN operational data for a particular
         node";
        list node {
          key "node-id";
          description
            "L2VPN operational data for a particular node";
          leaf node-id {
            type xr:Node-id;
            description "Location";
          }

          container discoveries {
            description "Discovery Table";
            list discovery {
              description
                "VPLS Discovery information";
              leaf service-name {
                type L2vpn-service;
                description "Service type";
              }

              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "Group Name";
              }

              leaf vpn-name {
                type xr:Cisco-ios-xr-string {
                  length "1..27";
                }
                description "VPN Name";
              }

              container signalling-info {
                description
                  "Info about signalling protocol";
                container bgp-sig-info {
                  when
                    "../ad-signalling-method = 'l2vpn-ad-sig-method-bgp'" {
                    description
                      "../ADSignallingMethod =
'L2VPN_AD_SIG_METHOD_BGP'";
                  }
                  description "bgp sig info";
                  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";
                    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";
                      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
                    }  // list label-block
                  }  // list edge

                  list redge {
                    description
                      "List of edge ids";
                    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";
                      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
                    }  // list label-block
                  }  // list redge
                }  // 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";
                  container local-vpls-id {
                    description
                      "Local VPLS-ID";
                    container auto {
                      when
                        "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                        description
                          "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                      }
                      description "auto";
                      leaf asn {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf vpn-id {
                        type uint32;
                        description "VPN ID";
                      }
                    }  // 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";
                      leaf two-byte-as {
                        type uint16;
                        description
                          "2 Byte AS Number";
                      }

                      leaf four-byte-index {
                        type uint32;
                        description
                          "4 Byte Index";
                      }
                    }  // 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";
                      leaf ipv4-address {
                        type inet:ipv4-address;
                        description
                          "IPv4 Address";
                      }

                      leaf two-byte-index {
                        type uint16;
                        description
                          "2 Byte Index";
                      }
                    }  // container v4-addr

                    leaf vpls-id-type {
                      type L2vpn-ad-vpls-id;
                      description
                        "VPLS ID TYPE";
                    }
                  }  // 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";
                    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";
                    }
                  }  // list remote-nlri
                }  // container ldp-sig-info

                leaf ad-signalling-method {
                  type L2vpn-ad-sig-method;
                  description
                    "ADSignallingMethod";
                }
              }  // 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";
              }
            }  // list discovery
          }  // container discoveries

          container flexible-xconnect-service-summary {
            description
              "Flexible XConnect Service summary information";
            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";
            }
          }  // container flexible-xconnect-service-summary

          container main-interfaces {
            description "Main Interface";
            list main-interface {
              key "interface-name";
              description
                "Main Interface Table";
              container main-interface-instances {
                description
                  "Main Interface Instance table";
                list main-interface-instance {
                  key "instance";
                  description
                    "Main Interface Instance";
                  container main-interface-instance-info {
                    description
                      "Main Interface Instance info";
                    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";
                    }
                  }  // container main-interface-instance-info

                  container main-interface-instance-bridge-ports {
                    description
                      "Main Interface Instance Bridge Port table";
                    list main-interface-instance-bridge-port {
                      key "bridge-port";
                      description
                        "Main Interface Bridge Port info";
                      leaf bridge-port {
                        type xr:Interface-name;
                        description
                          "Bridge Port";
                      }

                      leaf bridge-port-xr {
                        type xr:Interface-name;
                        description
                          "Bridge port ifhandle";
                      }

                      leaf instance-id {
                        type uint32;
                        description
                          "Instance ID";
                      }
                    }  // list main-interface-instance-bridge-port
                  }  // container main-interface-instance-bridge-ports

                  leaf instance {
                    type Msti-range;
                    description "Instance";
                  }
                }  // list main-interface-instance
              }  // container main-interface-instances

              container main-interface-info {
                description
                  "Main Interface info";
                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";
                }
              }  // container main-interface-info

              leaf interface-name {
                type xr:Interface-name;
                description "Main interface";
              }
            }  // list main-interface
          }  // container main-interfaces

          container iccp-sm {
            description
              "ICCP-based Service Multi-homing operational data";
            container iccp-sm-summary {
              description
                "ICCP-based Service Multi-homing database
summary";
              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";
              }
            }  // container iccp-sm-summary

            container iccp-groups {
              description "ICCP Group Table";
              list iccp-group {
                key "group-id";
                description "ICCP Group";
                container iccp-group-info {
                  description
                    "ICCP Group Information";
                  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";
                    container local-port {
                      description
                        "Local port info";
                      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";
                      }
                    }  // container local-port

                    container remote-port {
                      description
                        "Remote port info";
                      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";
                      }
                    }  // 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?";
                    }
                  }  // list ports
                }  // container iccp-group-info

                container iccp-ports {
                  description
                    "ICCP Port Table";
                  list iccp-port {
                    key "interface";
                    description "ICCP Port";
                    leaf interface {
                      type xr:Interface-name;
                      description
                        "Interface";
                    }

                    container local-port {
                      description
                        "Local port info";
                      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";
                      }
                    }  // container local-port

                    container remote-port {
                      description
                        "Remote port info";
                      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";
                      }
                    }  // 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?";
                    }
                  }  // list iccp-port
                }  // container iccp-ports

                leaf group-id {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description "Group ID";
                }
              }  // list iccp-group
            }  // container iccp-groups
          }  // container iccp-sm

          container bridge-summary {
            description
              "Bridge Domain summary information";
            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";
            }
          }  // container bridge-summary

          container nsr {
            description
              "L2VPN NSR information";
            container 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";
              }
            }  // container failover-status

            container nsr-status {
              description
                "L2VPN NSR status and timestamp";
              container idt-status {
                description "IDT status";
                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";
                }
              }  // container idt-status

              container previ-ous-idt-status {
                description
                  "Previous IDT status";
                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";
                }
              }  // container previ-ous-idt-status

              leaf nsr-role {
                type uint8;
                description "NSR role";
              }

              leaf issu-role {
                type uint8;
                description "ISSU role";
              }
            }  // container nsr-status

            container issu-status {
              description
                "L2VPN ISSU Status and timestamp";
              container idt-status {
                description "IDT status";
                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";
                }
              }  // container idt-status

              container previ-ous-idt-status {
                description
                  "Previous IDT status";
                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";
                }
              }  // container previ-ous-idt-status

              leaf nsr-role {
                type uint8;
                description "NSR role";
              }

              leaf issu-role {
                type uint8;
                description "ISSU role";
              }
            }  // 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";
              leaf app-type {
                type L2vpn-id-mgr-app-bag;
                description "App type";
              }

              leaf sent-ids {
                type uint32;
                description
                  "Number of XIDs transferred";
              }
            }  // list xid-info

            list report-card {
              description
                "L2VPN Collaborator 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";
              }
            }  // list report-card
          }  // container nsr

          container preferred-paths {
            description
              "Preferred path Table";
            list preferred-path {
              description
                "Preferred path information";
              leaf preferred-type {
                type Preferred-path-option;
                description "Preferred type";
              }

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

              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";
                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";
                }
              }  // list virtual-circuit
            }  // list preferred-path
          }  // container preferred-paths

          container pseudowire-headend {
            description
              "Pseudowire Headend related operational data";
            container detail-interfaces {
              description "PW-HE Interfaces";
              list detail-interface {
                key "interface-name";
                description
                  "PW-HE Interface detail";
                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "PWHE Interface name";
                }

                container l2-address {
                  description
                    "Layer2 Address";
                  container mac-address {
                    when
                      "../interface-type = 'pseudowire-ether'" {
                      description
                        "../InterfaceType = 'PseudowireEther'";
                    }
                    description
                      "MAC address";
                    leaf mac-address {
                      type yang:mac-address;
                      description
                        "MAC Address";
                    }
                  }  // container mac-address

                  leaf interface-type {
                    type L2vpn-pwhe-intf;
                    description
                      "InterfaceType";
                  }
                }  // container l2-address

                container generic-interface-list {
                  description
                    "Generic Interface List";
                  leaf generic-interface-list-name {
                    type string;
                    description
                      "Generic interface list name";
                  }

                  leaf id {
                    type uint32;
                    description
                      "Generic interface list ID";
                  }

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

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

                    leaf interface-state {
                      type Pwhe-port-im-state;
                      description
                        "Interface Status";
                    }

                    leaf replicate-state {
                      type L2vpn-pwhe-iflist-rep-status;
                      description
                        "Replication status";
                    }

                    leaf misconfigured {
                      type int32;
                      description
                        "Interface misconfigured";
                    }
                  }  // list interface-detail
                }  // container generic-interface-list

                leaf interface-state {
                  type Pwhe-port-im-state;
                  description
                    "Interface Status";
                }

                leaf admin-state {
                  type Pwhe-port-im-state;
                  description
                    "Interface Admin Status";
                }

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

                leaf bandwidth {
                  type uint32;
                  units "kbit/s";
                  description
                    "Bandwidth (Kbps)";
                }

                leaf label {
                  type uint32;
                  description "Label";
                }

                leaf l2-overhead {
                  type uint32;
                  description "L2 Overhead";
                }

                leaf vctype {
                  type uint32;
                  description "VC Type";
                }

                leaf control-word {
                  type int32;
                  description "Control Word";
                }
              }  // list detail-interface
            }  // container detail-interfaces

            container summary {
              description
                "PW-HE interface summary";
              leaf interfaces {
                type uint32;
                description
                  "Number of PW-HE interfaces";
              }

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

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

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

              leaf psuedowire-ether-interfaces {
                type uint32;
                description
                  "Number of PW-Ether interfaces";
              }

              leaf up-psuedowire-ether-interfaces {
                type uint32;
                description
                  "Number of PW-Ether interfaces up";
              }

              leaf down-pseudowire-ether-interfaces {
                type uint32;
                description
                  "Number of PW-Ether interfaces down";
              }

              leaf admin-down-pseudowire-ether-interfaces {
                type uint32;
                description
                  "Number of PW-Ether interfaces admin down";
              }

              leaf pseudowire-iw-interfaces {
                type uint32;
                description
                  "Number of PW-IW interfaces";
              }

              leaf up-pseudowire-iw-interfaces {
                type uint32;
                description
                  "Number of PW-IW interfaces up";
              }

              leaf down-pseudowire-iw-interfaces {
                type uint32;
                description
                  "Number of PW-IW interfaces down";
              }

              leaf admin-down-pseudowire-iw-interfaces {
                type uint32;
                description
                  "Number of PW-IW interfaces admin down";
              }
            }  // container summary
          }  // container pseudowire-headend

          container global-settings {
            description
              "L2VPN global settings";
            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";
            }
          }  // container global-settings

          container pwr {
            description
              "Pseudowire Routing Table";
            container summary {
              description
                "L2VPN Pseudowire Routing Summary";
              container rd-auto {
                description
                  "Automatic Route Distingtuisher";
                container auto {
                  when
                    "../rd = 'l2vpn-ad-rd-auto'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AUTO'";
                  }
                  description "auto";
                  leaf router-id {
                    type inet:ipv4-address;
                    description
                      "BGP Router ID";
                  }

                  leaf auto-index {
                    type uint16;
                    description
                      "Auto-generated Index";
                  }
                }  // container auto

                container two-byte-as {
                  when
                    "../rd = 'l2vpn-ad-rd-as'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rd = 'l2vpn-ad-rd-v4-addr'" {
                    description
                      "../RD = 'L2VPN_AD_RD_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                leaf rd {
                  type L2vpn-ad-rd;
                  description "RD";
                }
              }  // container rd-auto

              container rd-configured {
                description
                  "Configured Route Distinguisher";
                container auto {
                  when
                    "../rd = 'l2vpn-ad-rd-auto'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AUTO'";
                  }
                  description "auto";
                  leaf router-id {
                    type inet:ipv4-address;
                    description
                      "BGP Router ID";
                  }

                  leaf auto-index {
                    type uint16;
                    description
                      "Auto-generated Index";
                  }
                }  // container auto

                container two-byte-as {
                  when
                    "../rd = 'l2vpn-ad-rd-as'" {
                    description
                      "../RD = 'L2VPN_AD_RD_AS'";
                  }
                  description "two byte as";
                  leaf two-byte-as {
                    type uint16;
                    description
                      "2 Byte AS Number";
                  }

                  leaf four-byte-index {
                    type uint32;
                    description
                      "4 Byte Index";
                  }
                }  // 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";
                  leaf four-byte-as {
                    type uint32;
                    description
                      "4 Byte AS Number";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container four-byte-as

                container v4-addr {
                  when
                    "../rd = 'l2vpn-ad-rd-v4-addr'" {
                    description
                      "../RD = 'L2VPN_AD_RD_V4ADDR'";
                  }
                  description "v4 addr";
                  leaf ipv4-address {
                    type inet:ipv4-address;
                    description
                      "IPv4 Address";
                  }

                  leaf two-byte-index {
                    type uint16;
                    description
                      "2 Byte Index";
                  }
                }  // container v4-addr

                leaf rd {
                  type L2vpn-ad-rd;
                  description "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";
              }
            }  // container summary
          }  // container pwr

          container xconnect-mp2mp-ce2ces {
            description
              "XConnect MP2MP CE2CE Table";
            list xconnect-mp2mp-ce2ce {
              description
                "XConnect MP2MP CE2CE information";
              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "XConnect Group";
              }

              leaf mp2-mp-name {
                type xr:Cisco-ios-xr-string {
                  length "1..26";
                }
                description "Mp2Mp Name";
              }

              leaf local-ceid {
                type uint32 {
                  range "1..4294967295";
                }
                description "Local CE ID";
              }

              leaf remote-ceid {
                type uint32 {
                  range "1..4294967295";
                }
                description "Remote CE ID";
              }

              container backup {
                description "LCR backup";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // container backup

              container segment1 {
                description "Segment 1";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // container segment1

              container segment2 {
                description "Segment 2";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // container segment2

              container ce2ce {
                description "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";
                }
              }  // 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";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // list backup-segment
            }  // list xconnect-mp2mp-ce2ce
          }  // container xconnect-mp2mp-ce2ces

          container xconnects {
            description "XConnect Table";
            list xconnect {
              key "group-name xconnect-name";
              description
                "XConnect information";
              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "XConnect Group";
              }

              leaf xconnect-name {
                type string {
                  length "1..38";
                }
                description "XConnect Name";
              }

              container backup {
                description "LCR backup";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // container backup

              container segment1 {
                description "Segment 1";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // container segment1

              container segment2 {
                description "Segment 2";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // container segment2

              container ce2ce {
                description "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";
                }
              }  // 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";
                container attachment-circuit {
                  when
                    "../segment-type = 'l2vpn-segment-type-ac'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_AC'";
                  }
                  description
                    "Attachment Circuit";
                  container interface {
                    description "Interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container interface

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container l2vpn-protection {
                    description
                      "Protection object used for this segment";
                    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";
                    }
                  }  // 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";
                  }
                }  // container attachment-circuit

                container pseudo-wire {
                  when
                    "../segment-type = 'l2vpn-segment-type-pw'" {
                    description
                      "../SegmentType = 'L2VPN_SEGMENT_TYPE_PW'";
                  }
                  description "Pseudowire";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

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

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

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

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

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

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // container pseudo-wire

                leaf segment-type {
                  type L2vpn-segment;
                  description "SegmentType";
                }
              }  // list backup-segment
            }  // list xconnect
          }  // container xconnects

          container xconnect-groups {
            description
              "XConnect group Table";
            list xconnect-group {
              key "group-name";
              description
                "XConnect group information";
              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "XConnect Group";
              }

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

              leaf number-xconnects {
                type uint32;
                description
                  "Number of xconnects";
              }
            }  // list xconnect-group
          }  // container xconnect-groups

          container xconnect-mp2mps {
            description
              "XConnect MP2MP Table";
            list xconnect-mp2mp {
              key "group-name mp2-mp-name";
              description
                "XConnect MP2MP information";
              leaf group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description "XConnect Group";
              }

              leaf mp2-mp-name {
                type xr:Cisco-ios-xr-string {
                  length "1..26";
                }
                description "Mp2Mp Name";
              }

              container discovery {
                description
                  "l2vpn xc auto discovery info";
                container rd-value {
                  description
                    "Route Distinguisher";
                  container auto {
                    when
                      "../rd = 'l2vpn-ad-rd-auto'" {
                      description
                        "../RD = 'L2VPN_AD_RD_AUTO'";
                    }
                    description "auto";
                    leaf router-id {
                      type inet:ipv4-address;
                      description
                        "BGP Router ID";
                    }

                    leaf auto-index {
                      type uint16;
                      description
                        "Auto-generated Index";
                    }
                  }  // container auto

                  container two-byte-as {
                    when
                      "../rd = 'l2vpn-ad-rd-as'" {
                      description
                        "../RD = 'L2VPN_AD_RD_AS'";
                    }
                    description
                      "two byte as";
                    leaf two-byte-as {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf four-byte-index {
                      type uint32;
                      description
                        "4 Byte Index";
                    }
                  }  // 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";
                    leaf four-byte-as {
                      type uint32;
                      description
                        "4 Byte AS Number";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container four-byte-as

                  container v4-addr {
                    when
                      "../rd = 'l2vpn-ad-rd-v4-addr'" {
                      description
                        "../RD = 'L2VPN_AD_RD_V4ADDR'";
                    }
                    description "v4 addr";
                    leaf ipv4-address {
                      type inet:ipv4-address;
                      description
                        "IPv4 Address";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container v4-addr

                  leaf rd {
                    type L2vpn-ad-rd;
                    description "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";
                  container two-byte-as {
                    when
                      "../rt = 'l2vpn-ad-rt-as'" {
                      description
                        "../RT = 'L2VPN_AD_RT_AS'";
                    }
                    description
                      "two byte as";
                    leaf two-byte-as {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf four-byte-index {
                      type uint32;
                      description
                        "4 Byte Index";
                    }
                  }  // 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";
                    leaf four-byte-as {
                      type uint32;
                      description
                        "4 Byte AS Number";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container four-byte-as

                  container v4-addr {
                    when
                      "../rt = 'l2vpn-ad-rt-v4-addr'" {
                      description
                        "../RT = 'L2VPN_AD_RT_V4ADDR'";
                    }
                    description "v4 addr";
                    leaf ipv4-address {
                      type inet:ipv4-address;
                      description
                        "IPv4 Address";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container v4-addr

                  container es-import {
                    when
                      "../rt = 'es-import'" {
                      description
                        "../RT = 'ES_Import'";
                    }
                    description "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";
                    }
                  }  // container es-import

                  leaf rt {
                    type L2vpn-ad-rt;
                    description "RT";
                  }
                }  // list import-rt

                list export-rt {
                  description
                    "Export Route Targets";
                  container two-byte-as {
                    when
                      "../rt = 'l2vpn-ad-rt-as'" {
                      description
                        "../RT = 'L2VPN_AD_RT_AS'";
                    }
                    description
                      "two byte as";
                    leaf two-byte-as {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf four-byte-index {
                      type uint32;
                      description
                        "4 Byte Index";
                    }
                  }  // 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";
                    leaf four-byte-as {
                      type uint32;
                      description
                        "4 Byte AS Number";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container four-byte-as

                  container v4-addr {
                    when
                      "../rt = 'l2vpn-ad-rt-v4-addr'" {
                      description
                        "../RT = 'L2VPN_AD_RT_V4ADDR'";
                    }
                    description "v4 addr";
                    leaf ipv4-address {
                      type inet:ipv4-address;
                      description
                        "IPv4 Address";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container v4-addr

                  container es-import {
                    when
                      "../rt = 'es-import'" {
                      description
                        "../RT = 'ES_Import'";
                    }
                    description "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";
                    }
                  }  // container es-import

                  leaf rt {
                    type L2vpn-ad-rt;
                    description "RT";
                  }
                }  // list export-rt
              }  // 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";
              }
            }  // list xconnect-mp2mp
          }  // container xconnect-mp2mps

          container srte-policies {
            description "SRTE Policy Table";
            list srte-policy {
              description
                "SRTE Policy information";
              leaf color {
                type uint32;
                description "Policy Color";
              }

              leaf endpoint {
                type inet:ip-address-no-zone;
                description
                  "Policy Endpoint IP Address";
              }

              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";
              }
            }  // list srte-policy
          }  // container srte-policies

          container indexes {
            description
              "ID Manager Index Table";
            list index {
              key "pool-id";
              description
                "ID Manager Index Pool";
              leaf pool-id {
                type xr:Hex-integer;
                description "Pool ID";
              }

              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";
              }
            }  // list index
          }  // container indexes

          container xconnect-summary {
            description
              "XConnect summary information";
            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";
            }
          }  // container xconnect-summary

          container proc-fsm {
            description
              "L2VPN Process FSM information";
            container 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";
              }
            }  // container failover-status

            container nsr-status {
              description
                "L2VPN NSR status and timestamp";
              container idt-status {
                description "IDT status";
                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";
                }
              }  // container idt-status

              container previ-ous-idt-status {
                description
                  "Previous IDT status";
                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";
                }
              }  // container previ-ous-idt-status

              leaf nsr-role {
                type uint8;
                description "NSR role";
              }

              leaf issu-role {
                type uint8;
                description "ISSU role";
              }
            }  // container nsr-status

            container issu-status {
              description
                "L2VPN ISSU Status and timestamp";
              container idt-status {
                description "IDT status";
                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";
                }
              }  // container idt-status

              container previ-ous-idt-status {
                description
                  "Previous IDT status";
                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";
                }
              }  // container previ-ous-idt-status

              leaf nsr-role {
                type uint8;
                description "NSR role";
              }

              leaf issu-role {
                type uint8;
                description "ISSU role";
              }
            }  // 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";
              leaf app-type {
                type L2vpn-id-mgr-app-bag;
                description "App type";
              }

              leaf sent-ids {
                type uint32;
                description
                  "Number of XIDs transferred";
              }
            }  // list xid-info

            list report-card {
              description
                "L2VPN Collaborator 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";
              }
            }  // list report-card
          }  // container proc-fsm

          container mstp-ports {
            description
              "L2VPN MSTP Port Table";
            list mstp-port {
              key "interface";
              description
                "MSTP Port information";
              leaf interface {
                type xr:Interface-name;
                description "Interface";
              }

              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";
                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";
                  leaf bdid {
                    type uint32;
                    description "BD ID";
                  }

                  leaf bdif-count {
                    type uint32;
                    description
                      "BD Intf Count";
                  }
                }  // list bd-entry
              }  // list msti-entry
            }  // list mstp-port
          }  // container mstp-ports

          container generic-interface-list-details {
            description
              "L2VPN generic interface list Detail Table";
            list generic-interface-list-detail {
              key "interface-list-name";
              description
                "Generic Interface List detail information";
              leaf interface-list-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Generic Interface List Name";
              }

              container summary {
                description
                  "Summary information";
                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";
                  leaf interface-name {
                    type string;
                    description
                      "Interface name";
                  }

                  leaf pending-replications {
                    type uint32;
                    description
                      "Number of pending replications";
                  }

                  leaf not-supported-replications {
                    type uint32;
                    description
                      "Number of replications failed because
unsupported";
                  }

                  leaf is-fib-downloaded {
                    type boolean;
                    description
                      "Is interface downloaded to FIB";
                  }
                }  // list interface
              }  // 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";
                leaf interface-name {
                  type string;
                  description
                    "Interface name";
                }

                leaf pending-replications {
                  type uint32;
                  description
                    "Number of pending replications";
                }

                leaf not-supported-replications {
                  type uint32;
                  description
                    "Number of replications failed because
unsupported";
                }

                leaf is-fib-downloaded {
                  type boolean;
                  description
                    "Is interface downloaded to FIB";
                }
              }  // list interface

              list pseudowire-ether-range {
                description
                  "PW-Ether ranges";
                leaf lower {
                  type uint16;
                  description "lower range";
                }

                leaf upper {
                  type uint16;
                  description "upper range";
                }
              }  // list pseudowire-ether-range

              list pseudowire-iw-range {
                description "PW-IW ranges";
                leaf lower {
                  type uint16;
                  description "lower range";
                }

                leaf upper {
                  type uint16;
                  description "upper range";
                }
              }  // list pseudowire-iw-range
            }  // list generic-interface-list-detail
          }  // container generic-interface-list-details

          container l2vpn-resource-state {
            description
              "L2VPN resource state information";
            leaf resource-out-of-memory-state {
              type uint32;
              description
                "L2VPN Out of memory state";
            }
          }  // container l2vpn-resource-state

          container bridge-domains {
            description
              "Bridge Domain Information";
            list bridge-domain {
              key "bridge-domain-group-name bridge-domain-name";
              description
                "Bridge Domain Information";
              container bridge-access-vfi-table {
                description
                  "Bridge Domain Access VFI Table";
                container bridge-pws {
                  description
                    "Bridge Domain Access/Core Pseudowire Table";
                  list bridge-pw {
                    description
                      "Bridge Domain Pseudowire";
                    leaf neighbor {
                      type inet:ipv4-address-no-zone;
                      description
                        "Neighbor IPv4 address";
                    }

                    leaf pw-type {
                      type L2vpnpw;
                      description "PW Type";
                    }

                    leaf pseudowire-id {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "Pseudowire ID";
                    }

                    leaf ve-id-vpls-id-0-3 {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                    }

                    leaf vpls-id-4-7 {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "Zero or Last 4 bytes of VPLS-ID";
                    }

                    container pseudowire {
                      description
                        "Pseudowire";
                      container peer-id {
                        description "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";
                        }
                      }  // container peer-id

                      container encapsulation-info {
                        description
                          "Encapsulation specific pseudowire information";
                        container atom {
                          when
                            "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                            description
                              "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                          }
                          description "atom";
                          container local-agi {
                            description
                              "Local Attachment Group Identifier";
                            container auto {
                              when
                                "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                                description
                                  "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                              }
                              description
                                "auto";
                              leaf asn {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf vpn-id {
                                type uint32;
                                description
                                  "VPN ID";
                              }
                            }  // 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";
                              leaf two-byte-as {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf four-byte-index {
                                type uint32;
                                description
                                  "4 Byte Index";
                              }
                            }  // 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";
                              leaf ipv4-address {
                                type inet:ipv4-address;
                                description
                                  "IPv4 Address";
                              }

                              leaf two-byte-index {
                                type uint16;
                                description
                                  "2 Byte Index";
                              }
                            }  // container v4-addr

                            leaf vpls-id-type {
                              type L2vpn-ad-vpls-id;
                              description
                                "VPLS ID TYPE";
                            }
                          }  // container local-agi

                          container remote-agi {
                            description
                              "Remote Attachment Group Identifier";
                            container auto {
                              when
                                "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                                description
                                  "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                              }
                              description
                                "auto";
                              leaf asn {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf vpn-id {
                                type uint32;
                                description
                                  "VPN ID";
                              }
                            }  // 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";
                              leaf two-byte-as {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf four-byte-index {
                                type uint32;
                                description
                                  "4 Byte Index";
                              }
                            }  // 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";
                              leaf ipv4-address {
                                type inet:ipv4-address;
                                description
                                  "IPv4 Address";
                              }

                              leaf two-byte-index {
                                type uint16;
                                description
                                  "2 Byte Index";
                              }
                            }  // container v4-addr

                            leaf vpls-id-type {
                              type L2vpn-ad-vpls-id;
                              description
                                "VPLS ID TYPE";
                            }
                          }  // container remote-agi

                          container multi-segment-pseudowire-stats {
                            description
                              "Multisegment pseudowire statistics";
                            leaf received-packets {
                              type uint64;
                              description
                                "Packets received";
                            }

                            leaf received-bytes {
                              type uint64;
                              units "byte";
                              description
                                "Bytes received";
                            }
                          }  // 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";
                          }
                        }  // container atom

                        container l2tpv3 {
                          when
                            "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                            description
                              "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                          }
                          description
                            "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";
                          }
                        }  // container l2tpv3

                        container srv6 {
                          when
                            "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                            description
                              "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                          }
                          description "srv6";
                          container srv6-headend-behavior {
                            description
                              "Headend behavior in use";
                            leaf type {
                              type Mgmt-srv6-headend;
                              description
                                "Behavior type";
                            }

                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // container srv6-headend-behavior

                          container srv6-endpoint-behavior {
                            description
                              "Endpoint behavior in use";
                            leaf type {
                              type Mgmt-srv6-endpoint;
                              description
                                "Behavior type";
                            }

                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // 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";
                            container sr-te-info {
                              description
                                "SR(v6)-TE Policy info from ODN";
                              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";
                              }
                            }  // container sr-te-info

                            container layer2-attributes {
                              description
                                "Layer 2 Attributes";
                              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";
                              }
                            }  // 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";
                              leaf srv6-sid {
                                type inet:ipv6-address;
                                description
                                  "SRv6 SID";
                              }
                            }  // list srv6-sid-info
                          }  // list remote-path-buffer
                        }  // container srv6

                        leaf encapsulation {
                          type L2vpn-encap-method;
                          description
                            "Encapsulation";
                        }
                      }  // container encapsulation-info

                      container local-interface {
                        description
                          "Local interface";
                        container parameters {
                          description
                            "Interface parameters";
                          container ethernet {
                            when
                              "../type = 'l2vpn-intf-type-ethernet'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                            }
                            description
                              "Ethernet";
                            leaf xconnect-tags {
                              type uint8;
                              description
                                "XConnect tags";
                            }
                          }  // container ethernet

                          container vlan {
                            when
                              "../type = 'l2vpn-intf-type-vlan'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                            }
                            description
                              "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";
                              leaf lower {
                                type uint16;
                                description
                                  "Lower";
                              }

                              leaf upper {
                                type uint16;
                                description
                                  "Upper";
                              }
                            }  // list vlan-range
                          }  // container vlan

                          container tdm {
                            when
                              "../type = 'l2vpn-intf-type-cem'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_CEM'";
                            }
                            description
                              "TDM";
                            container tdm-options {
                              description
                                "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";
                              }
                            }  // 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";
                            }
                          }  // container tdm

                          container atm {
                            when
                              "../type = 'l2vpn-intf-type-atm'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ATM'";
                            }
                            description
                              "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";
                            }
                          }  // container atm

                          container fr {
                            when
                              "../type = 'l2vpn-intf-type-frame-relay'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                            }
                            description
                              "Frame Relay";
                            leaf fr-mode {
                              type L2vpn-fr-mode;
                              description
                                "Frame Relay mode";
                            }

                            leaf dlci {
                              type uint32;
                              description
                                "Data-link connection identifier";
                            }
                          }  // container fr

                          container pseudowire-ether {
                            when
                              "../type = 'l2vpn-intf-type-pw-ether'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                            }
                            description
                              "PW Ether";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

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

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

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

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-ether

                          container pseudowire-iw {
                            when
                              "../type = 'l2vpn-intf-type-pw-iw'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                            }
                            description
                              "PW IW";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

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

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

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

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-iw

                          leaf type {
                            type L2vpn-interface;
                            description
                              "Type";
                          }
                        }  // 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";
                        }
                      }  // container local-interface

                      container remote-interface {
                        description
                          "Remote interface";
                        container parameters {
                          description
                            "Interface parameters";
                          container ethernet {
                            when
                              "../type = 'l2vpn-intf-type-ethernet'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                            }
                            description
                              "Ethernet";
                            leaf xconnect-tags {
                              type uint8;
                              description
                                "XConnect tags";
                            }
                          }  // container ethernet

                          container vlan {
                            when
                              "../type = 'l2vpn-intf-type-vlan'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                            }
                            description
                              "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";
                              leaf lower {
                                type uint16;
                                description
                                  "Lower";
                              }

                              leaf upper {
                                type uint16;
                                description
                                  "Upper";
                              }
                            }  // list vlan-range
                          }  // container vlan

                          container tdm {
                            when
                              "../type = 'l2vpn-intf-type-cem'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_CEM'";
                            }
                            description
                              "TDM";
                            container tdm-options {
                              description
                                "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";
                              }
                            }  // 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";
                            }
                          }  // container tdm

                          container atm {
                            when
                              "../type = 'l2vpn-intf-type-atm'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ATM'";
                            }
                            description
                              "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";
                            }
                          }  // container atm

                          container fr {
                            when
                              "../type = 'l2vpn-intf-type-frame-relay'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                            }
                            description
                              "Frame Relay";
                            leaf fr-mode {
                              type L2vpn-fr-mode;
                              description
                                "Frame Relay mode";
                            }

                            leaf dlci {
                              type uint32;
                              description
                                "Data-link connection identifier";
                            }
                          }  // container fr

                          container pseudowire-ether {
                            when
                              "../type = 'l2vpn-intf-type-pw-ether'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                            }
                            description
                              "PW Ether";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

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

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

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

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-ether

                          container pseudowire-iw {
                            when
                              "../type = 'l2vpn-intf-type-pw-iw'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                            }
                            description
                              "PW IW";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

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

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

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

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-iw

                          leaf type {
                            type L2vpn-interface;
                            description
                              "Type";
                          }
                        }  // 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";
                        }
                      }  // container remote-interface

                      container preferred-path {
                        description
                          "MPLS Preferred Path";
                        container srte-policy {
                          when
                            "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                            description
                              "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                          }
                          description
                            "srte policy";
                          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";
                          }
                        }  // 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";
                          leaf te-named-tunnel {
                            type string;
                            description
                              "TE Tunnel Name";
                          }
                        }  // 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";
                        }
                      }  // container preferred-path

                      container local-signalling {
                        description
                          "Local signalling";
                        container status-tlv {
                          description
                            "PW Status Switching TLV";
                          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";
                          }
                        }  // container status-tlv

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

                        list tlv {
                          description
                            "Switching 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";
                          }
                        }  // list tlv
                      }  // container local-signalling

                      container remote-signalling {
                        description
                          "Remote signalling";
                        container status-tlv {
                          description
                            "PW Status Switching TLV";
                          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";
                          }
                        }  // container status-tlv

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

                        list tlv {
                          description
                            "Switching 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";
                          }
                        }  // list tlv
                      }  // container remote-signalling

                      container statistics {
                        description
                          "Statistics";
                        container imposition-stats {
                          description
                            "imposition stats";
                          container imposition-stat {
                            description
                              "imposition stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-stat

                          container imposition-mtu-drop {
                            description
                              "imposition mtu drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-mtu-drop

                          container imposition-tail-drop {
                            description
                              "imposition tail drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-tail-drop

                          container l2fsbi-drop {
                            description
                              "rx discards";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container l2fsbi-drop

                          container multicast {
                            description
                              "Multicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container multicast

                          container broadcast {
                            description
                              "Broadcast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container broadcast

                          container known-unicast {
                            description
                              "Known Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container known-unicast

                          container unknown-unicast {
                            description
                              "Unknown Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container unknown-unicast
                        }  // container imposition-stats

                        container disposition-stats {
                          description
                            "disposition stats";
                          container disposition-stat {
                            description
                              "disposition stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-stat

                          container disposition-mtu-drop {
                            description
                              "disposition mtu drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-mtu-drop

                          container disposition-tail-drop {
                            description
                              "disposition tail drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-tail-drop

                          container multicast-drop {
                            description
                              "disposition storm control multicast drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container multicast-drop

                          container unicast-drop {
                            description
                              "disposition storm control unknown unicast drop
stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container unicast-drop

                          container broadcast-drop {
                            description
                              "disposition storm control broadcast drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container broadcast-drop

                          container received-drops {
                            description
                              "tx discards";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container received-drops

                          container dai-drop {
                            description
                              "Disposition dynamic ARP inspection drop
statistics";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container dai-drop

                          container ipsg-drop {
                            description
                              "disposition IP source guard drop statistics";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container ipsg-drop

                          container disposition-oo-o-drops {
                            description
                              "Disposition Out-of-Order Drops";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-oo-o-drops

                          container disposition-p2mp-stats {
                            description
                              "Disposition P2MP Stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-p2mp-stats

                          container known-unicast {
                            description
                              "Known Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container known-unicast

                          container mac-move {
                            description
                              "MAC Move";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container mac-move
                        }  // container disposition-stats

                        container sequence-number {
                          description
                            "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";
                          }
                        }  // container sequence-number
                      }  // container statistics

                      container p2mp-pw {
                        description
                          "P2MP Pseudowire Information";
                        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)";
                        }
                      }  // 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
                    }  // container pseudowire

                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container security-parameters

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

                    list static-mac {
                      description
                        "Static MAC addresses";
                      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";
                      }
                    }  // list static-mac
                  }  // list bridge-pw
                }  // container bridge-pws
              }  // container bridge-access-vfi-table

              container bridge-core-vfi-table {
                description
                  "Bridge Domain Core VFI Table";
                container bridge-pws {
                  description
                    "Bridge Domain Access/Core Pseudowire Table";
                  list bridge-pw {
                    description
                      "Bridge Domain Pseudowire";
                    leaf neighbor {
                      type inet:ipv4-address-no-zone;
                      description
                        "Neighbor IPv4 address";
                    }

                    leaf pw-type {
                      type L2vpnpw;
                      description "PW Type";
                    }

                    leaf pseudowire-id {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "Pseudowire ID";
                    }

                    leaf ve-id-vpls-id-0-3 {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                    }

                    leaf vpls-id-4-7 {
                      type uint32 {
                        range
                          "0..4294967295";
                      }
                      description
                        "Zero or Last 4 bytes of VPLS-ID";
                    }

                    container pseudowire {
                      description
                        "Pseudowire";
                      container peer-id {
                        description "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";
                        }
                      }  // container peer-id

                      container encapsulation-info {
                        description
                          "Encapsulation specific pseudowire information";
                        container atom {
                          when
                            "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                            description
                              "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                          }
                          description "atom";
                          container local-agi {
                            description
                              "Local Attachment Group Identifier";
                            container auto {
                              when
                                "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                                description
                                  "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                              }
                              description
                                "auto";
                              leaf asn {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf vpn-id {
                                type uint32;
                                description
                                  "VPN ID";
                              }
                            }  // 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";
                              leaf two-byte-as {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf four-byte-index {
                                type uint32;
                                description
                                  "4 Byte Index";
                              }
                            }  // 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";
                              leaf ipv4-address {
                                type inet:ipv4-address;
                                description
                                  "IPv4 Address";
                              }

                              leaf two-byte-index {
                                type uint16;
                                description
                                  "2 Byte Index";
                              }
                            }  // container v4-addr

                            leaf vpls-id-type {
                              type L2vpn-ad-vpls-id;
                              description
                                "VPLS ID TYPE";
                            }
                          }  // container local-agi

                          container remote-agi {
                            description
                              "Remote Attachment Group Identifier";
                            container auto {
                              when
                                "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                                description
                                  "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                              }
                              description
                                "auto";
                              leaf asn {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf vpn-id {
                                type uint32;
                                description
                                  "VPN ID";
                              }
                            }  // 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";
                              leaf two-byte-as {
                                type uint16;
                                description
                                  "2 Byte AS Number";
                              }

                              leaf four-byte-index {
                                type uint32;
                                description
                                  "4 Byte Index";
                              }
                            }  // 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";
                              leaf ipv4-address {
                                type inet:ipv4-address;
                                description
                                  "IPv4 Address";
                              }

                              leaf two-byte-index {
                                type uint16;
                                description
                                  "2 Byte Index";
                              }
                            }  // container v4-addr

                            leaf vpls-id-type {
                              type L2vpn-ad-vpls-id;
                              description
                                "VPLS ID TYPE";
                            }
                          }  // container remote-agi

                          container multi-segment-pseudowire-stats {
                            description
                              "Multisegment pseudowire statistics";
                            leaf received-packets {
                              type uint64;
                              description
                                "Packets received";
                            }

                            leaf received-bytes {
                              type uint64;
                              units "byte";
                              description
                                "Bytes received";
                            }
                          }  // 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";
                          }
                        }  // container atom

                        container l2tpv3 {
                          when
                            "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                            description
                              "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                          }
                          description
                            "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";
                          }
                        }  // container l2tpv3

                        container srv6 {
                          when
                            "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                            description
                              "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                          }
                          description "srv6";
                          container srv6-headend-behavior {
                            description
                              "Headend behavior in use";
                            leaf type {
                              type Mgmt-srv6-headend;
                              description
                                "Behavior type";
                            }

                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // container srv6-headend-behavior

                          container srv6-endpoint-behavior {
                            description
                              "Endpoint behavior in use";
                            leaf type {
                              type Mgmt-srv6-endpoint;
                              description
                                "Behavior type";
                            }

                            leaf description {
                              type string;
                              description
                                "Behavior description";
                            }
                          }  // 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";
                            container sr-te-info {
                              description
                                "SR(v6)-TE Policy info from ODN";
                              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";
                              }
                            }  // container sr-te-info

                            container layer2-attributes {
                              description
                                "Layer 2 Attributes";
                              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";
                              }
                            }  // 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";
                              leaf srv6-sid {
                                type inet:ipv6-address;
                                description
                                  "SRv6 SID";
                              }
                            }  // list srv6-sid-info
                          }  // list remote-path-buffer
                        }  // container srv6

                        leaf encapsulation {
                          type L2vpn-encap-method;
                          description
                            "Encapsulation";
                        }
                      }  // container encapsulation-info

                      container local-interface {
                        description
                          "Local interface";
                        container parameters {
                          description
                            "Interface parameters";
                          container ethernet {
                            when
                              "../type = 'l2vpn-intf-type-ethernet'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                            }
                            description
                              "Ethernet";
                            leaf xconnect-tags {
                              type uint8;
                              description
                                "XConnect tags";
                            }
                          }  // container ethernet

                          container vlan {
                            when
                              "../type = 'l2vpn-intf-type-vlan'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                            }
                            description
                              "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";
                              leaf lower {
                                type uint16;
                                description
                                  "Lower";
                              }

                              leaf upper {
                                type uint16;
                                description
                                  "Upper";
                              }
                            }  // list vlan-range
                          }  // container vlan

                          container tdm {
                            when
                              "../type = 'l2vpn-intf-type-cem'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_CEM'";
                            }
                            description
                              "TDM";
                            container tdm-options {
                              description
                                "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";
                              }
                            }  // 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";
                            }
                          }  // container tdm

                          container atm {
                            when
                              "../type = 'l2vpn-intf-type-atm'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ATM'";
                            }
                            description
                              "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";
                            }
                          }  // container atm

                          container fr {
                            when
                              "../type = 'l2vpn-intf-type-frame-relay'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                            }
                            description
                              "Frame Relay";
                            leaf fr-mode {
                              type L2vpn-fr-mode;
                              description
                                "Frame Relay mode";
                            }

                            leaf dlci {
                              type uint32;
                              description
                                "Data-link connection identifier";
                            }
                          }  // container fr

                          container pseudowire-ether {
                            when
                              "../type = 'l2vpn-intf-type-pw-ether'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                            }
                            description
                              "PW Ether";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

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

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

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

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-ether

                          container pseudowire-iw {
                            when
                              "../type = 'l2vpn-intf-type-pw-iw'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                            }
                            description
                              "PW IW";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

                              leaf interface-list-id {
                                type uint32;
                                description
                                  "Interface internal ID";
                              }

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

                            leaf is-valid {
                              type boolean;
                              description
                                "Is this Interface list valid";
                            }

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-iw

                          leaf type {
                            type L2vpn-interface;
                            description
                              "Type";
                          }
                        }  // 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";
                        }
                      }  // container local-interface

                      container remote-interface {
                        description
                          "Remote interface";
                        container parameters {
                          description
                            "Interface parameters";
                          container ethernet {
                            when
                              "../type = 'l2vpn-intf-type-ethernet'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                            }
                            description
                              "Ethernet";
                            leaf xconnect-tags {
                              type uint8;
                              description
                                "XConnect tags";
                            }
                          }  // container ethernet

                          container vlan {
                            when
                              "../type = 'l2vpn-intf-type-vlan'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                            }
                            description
                              "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";
                              leaf lower {
                                type uint16;
                                description
                                  "Lower";
                              }

                              leaf upper {
                                type uint16;
                                description
                                  "Upper";
                              }
                            }  // list vlan-range
                          }  // container vlan

                          container tdm {
                            when
                              "../type = 'l2vpn-intf-type-cem'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_CEM'";
                            }
                            description
                              "TDM";
                            container tdm-options {
                              description
                                "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";
                              }
                            }  // 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";
                            }
                          }  // container tdm

                          container atm {
                            when
                              "../type = 'l2vpn-intf-type-atm'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_ATM'";
                            }
                            description
                              "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";
                            }
                          }  // container atm

                          container fr {
                            when
                              "../type = 'l2vpn-intf-type-frame-relay'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                            }
                            description
                              "Frame Relay";
                            leaf fr-mode {
                              type L2vpn-fr-mode;
                              description
                                "Frame Relay mode";
                            }

                            leaf dlci {
                              type uint32;
                              description
                                "Data-link connection identifier";
                            }
                          }  // container fr

                          container pseudowire-ether {
                            when
                              "../type = 'l2vpn-intf-type-pw-ether'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                            }
                            description
                              "PW Ether";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

                              leaf interface-list-id {
                                type uint32;
                                description
                                  "Interface internal ID";
                              }

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

                            leaf is-valid {
                              type boolean;
                              description
                                "Is this Interface list valid";
                            }

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-ether

                          container pseudowire-iw {
                            when
                              "../type = 'l2vpn-intf-type-pw-iw'" {
                              description
                                "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                            }
                            description
                              "PW IW";
                            container interface-list {
                              description
                                "Interface list data";
                              leaf interface-list-name {
                                type string {
                                  length
                                    "0..33";
                                }
                                description
                                  "Interface-list name";
                              }

                              leaf interface-list-id {
                                type uint32;
                                description
                                  "Interface internal ID";
                              }

                              list interface {
                                max-elements
                                  32;
                                description
                                  "Interfaces";
                                leaf interface-name {
                                  type string;
                                  description
                                    "Interface name";
                                }

                                leaf replicate-status {
                                  type Iflist-rep-status;
                                  description
                                    "Replicate status";
                                }
                              }  // list interface
                            }  // container interface-list

                            leaf is-valid {
                              type boolean;
                              description
                                "Is this Interface list valid";
                            }

                            leaf internal-label {
                              type uint32;
                              description
                                "Internal Label";
                            }
                          }  // container pseudowire-iw

                          leaf type {
                            type L2vpn-interface;
                            description
                              "Type";
                          }
                        }  // 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";
                        }
                      }  // container remote-interface

                      container preferred-path {
                        description
                          "MPLS Preferred Path";
                        container srte-policy {
                          when
                            "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                            description
                              "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                          }
                          description
                            "srte policy";
                          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";
                          }
                        }  // 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";
                          leaf te-named-tunnel {
                            type string;
                            description
                              "TE Tunnel Name";
                          }
                        }  // 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";
                        }
                      }  // container preferred-path

                      container local-signalling {
                        description
                          "Local signalling";
                        container status-tlv {
                          description
                            "PW Status Switching TLV";
                          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";
                          }
                        }  // container status-tlv

                        leaf pw-status {
                          type uint32;
                          description
                            "PW Status";
                        }

                        list tlv {
                          description
                            "Switching 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";
                          }
                        }  // list tlv
                      }  // container local-signalling

                      container remote-signalling {
                        description
                          "Remote signalling";
                        container status-tlv {
                          description
                            "PW Status Switching TLV";
                          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";
                          }
                        }  // container status-tlv

                        leaf pw-status {
                          type uint32;
                          description
                            "PW Status";
                        }

                        list tlv {
                          description
                            "Switching 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";
                          }
                        }  // list tlv
                      }  // container remote-signalling

                      container statistics {
                        description
                          "Statistics";
                        container imposition-stats {
                          description
                            "imposition stats";
                          container imposition-stat {
                            description
                              "imposition stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-stat

                          container imposition-mtu-drop {
                            description
                              "imposition mtu drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-mtu-drop

                          container imposition-tail-drop {
                            description
                              "imposition tail drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-tail-drop

                          container l2fsbi-drop {
                            description
                              "rx discards";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container l2fsbi-drop

                          container multicast {
                            description
                              "Multicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container multicast

                          container broadcast {
                            description
                              "Broadcast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container broadcast

                          container known-unicast {
                            description
                              "Known Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container known-unicast

                          container unknown-unicast {
                            description
                              "Unknown Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container unknown-unicast
                        }  // container imposition-stats

                        container disposition-stats {
                          description
                            "disposition stats";
                          container disposition-stat {
                            description
                              "disposition stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-stat

                          container disposition-mtu-drop {
                            description
                              "disposition mtu drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-mtu-drop

                          container disposition-tail-drop {
                            description
                              "disposition tail drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-tail-drop

                          container multicast-drop {
                            description
                              "disposition storm control multicast drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container multicast-drop

                          container unicast-drop {
                            description
                              "disposition storm control unknown unicast drop
stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container unicast-drop

                          container broadcast-drop {
                            description
                              "disposition storm control broadcast drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container broadcast-drop

                          container received-drops {
                            description
                              "tx discards";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container received-drops

                          container dai-drop {
                            description
                              "Disposition dynamic ARP inspection drop
statistics";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container dai-drop

                          container ipsg-drop {
                            description
                              "disposition IP source guard drop statistics";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container ipsg-drop

                          container disposition-oo-o-drops {
                            description
                              "Disposition Out-of-Order Drops";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-oo-o-drops

                          container disposition-p2mp-stats {
                            description
                              "Disposition P2MP Stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-p2mp-stats

                          container known-unicast {
                            description
                              "Known Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container known-unicast

                          container mac-move {
                            description
                              "MAC Move";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container mac-move
                        }  // container disposition-stats

                        container sequence-number {
                          description
                            "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";
                          }
                        }  // container sequence-number
                      }  // container statistics

                      container p2mp-pw {
                        description
                          "P2MP Pseudowire Information";
                        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)";
                        }
                      }  // 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
                    }  // container pseudowire

                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container security-parameters

                    leaf is-access {
                      type boolean;
                      description
                        "Is Access PW";
                    }

                    list static-mac {
                      description
                        "Static MAC addresses";
                      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";
                      }
                    }  // list static-mac
                  }  // list bridge-pw
                }  // container bridge-pws
              }  // container bridge-core-vfi-table

              container bridge-acs {
                description
                  "Bridge Domain Attachment Circuit Table";
                list bridge-ac {
                  key "interface-name";
                  description
                    "Bridge Domain Attachment Circuit";
                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Interface Name";
                  }

                  container attachment-circuit {
                    description
                      "Attachment Circuit";
                    container interface {
                      description
                        "Interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container interface

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container l2vpn-protection {
                      description
                        "Protection object used for this segment";
                      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";
                      }
                    }  // 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";
                    }
                  }  // container attachment-circuit

                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

                  leaf bvi-mac-index {
                    type uint16;
                    description
                      "MyMac Index";
                  }

                  list static-mac {
                    description
                      "Static MAC addresses";
                    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";
                    }
                  }  // list static-mac

                  list bvimac {
                    description
                      "BVI MAC addresses";
                    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";
                    }
                  }  // list bvimac
                }  // list bridge-ac
              }  // container bridge-acs

              container bridge-access-pws {
                description
                  "Bridge Domain Access Pseudowire Table";
                list bridge-access-pw {
                  description
                    "Bridge Domain Access Pseudowire";
                  leaf neighbor {
                    type inet:ipv4-address-no-zone;
                    description
                      "Neighbor IPv4 address";
                  }

                  leaf pw-type {
                    type L2vpnpw;
                    description "PW Type";
                  }

                  leaf pseudowire-id {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Pseudowire ID";
                  }

                  leaf ve-id-vpls-id-0-3 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or concatenation of local and remote
VE-ID or first 4 bytes of VPLS-ID";
                  }

                  leaf vpls-id-4-7 {
                    type uint32 {
                      range "0..4294967295";
                    }
                    description
                      "Zero or Last 4 bytes of VPLS-ID";
                  }

                  container pseudowire {
                    description "Pseudowire";
                    container peer-id {
                      description "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";
                      }
                    }  // container peer-id

                    container encapsulation-info {
                      description
                        "Encapsulation specific pseudowire information";
                      container atom {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                        }
                        description "atom";
                        container local-agi {
                          description
                            "Local Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container local-agi

                        container remote-agi {
                          description
                            "Remote Attachment Group Identifier";
                          container auto {
                            when
                              "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                              description
                                "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                            }
                            description
                              "auto";
                            leaf asn {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf vpn-id {
                              type uint32;
                              description
                                "VPN ID";
                            }
                          }  // 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";
                            leaf two-byte-as {
                              type uint16;
                              description
                                "2 Byte AS Number";
                            }

                            leaf four-byte-index {
                              type uint32;
                              description
                                "4 Byte Index";
                            }
                          }  // 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";
                            leaf ipv4-address {
                              type inet:ipv4-address;
                              description
                                "IPv4 Address";
                            }

                            leaf two-byte-index {
                              type uint16;
                              description
                                "2 Byte Index";
                            }
                          }  // container v4-addr

                          leaf vpls-id-type {
                            type L2vpn-ad-vpls-id;
                            description
                              "VPLS ID TYPE";
                          }
                        }  // container remote-agi

                        container multi-segment-pseudowire-stats {
                          description
                            "Multisegment pseudowire statistics";
                          leaf received-packets {
                            type uint64;
                            description
                              "Packets received";
                          }

                          leaf received-bytes {
                            type uint64;
                            units "byte";
                            description
                              "Bytes received";
                          }
                        }  // 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";
                        }
                      }  // container atom

                      container l2tpv3 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                        }
                        description "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";
                        }
                      }  // container l2tpv3

                      container srv6 {
                        when
                          "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                          description
                            "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                        }
                        description "srv6";
                        container srv6-headend-behavior {
                          description
                            "Headend behavior in use";
                          leaf type {
                            type Mgmt-srv6-headend;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // container srv6-headend-behavior

                        container srv6-endpoint-behavior {
                          description
                            "Endpoint behavior in use";
                          leaf type {
                            type Mgmt-srv6-endpoint;
                            description
                              "Behavior type";
                          }

                          leaf description {
                            type string;
                            description
                              "Behavior description";
                          }
                        }  // 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";
                          container sr-te-info {
                            description
                              "SR(v6)-TE Policy info from ODN";
                            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";
                            }
                          }  // container sr-te-info

                          container layer2-attributes {
                            description
                              "Layer 2 Attributes";
                            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";
                            }
                          }  // 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";
                            leaf srv6-sid {
                              type inet:ipv6-address;
                              description
                                "SRv6 SID";
                            }
                          }  // list srv6-sid-info
                        }  // list remote-path-buffer
                      }  // container srv6

                      leaf encapsulation {
                        type L2vpn-encap-method;
                        description
                          "Encapsulation";
                      }
                    }  // container encapsulation-info

                    container local-interface {
                      description
                        "Local interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container local-interface

                    container remote-interface {
                      description
                        "Remote interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container remote-interface

                    container preferred-path {
                      description
                        "MPLS Preferred Path";
                      container srte-policy {
                        when
                          "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                          description
                            "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                        }
                        description
                          "srte policy";
                        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";
                        }
                      }  // 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";
                        leaf te-named-tunnel {
                          type string;
                          description
                            "TE Tunnel Name";
                        }
                      }  // 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";
                      }
                    }  // container preferred-path

                    container local-signalling {
                      description
                        "Local signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

                      leaf pw-status {
                        type uint32;
                        description
                          "PW Status";
                      }

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container local-signalling

                    container remote-signalling {
                      description
                        "Remote signalling";
                      container status-tlv {
                        description
                          "PW Status Switching TLV";
                        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";
                        }
                      }  // container status-tlv

                      leaf pw-status {
                        type uint32;
                        description
                          "PW Status";
                      }

                      list tlv {
                        description
                          "Switching 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";
                        }
                      }  // list tlv
                    }  // container remote-signalling

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container p2mp-pw {
                      description
                        "P2MP Pseudowire Information";
                      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)";
                      }
                    }  // 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
                  }  // container pseudowire

                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

                  leaf is-access {
                    type boolean;
                    description
                      "Is Access PW";
                  }

                  list static-mac {
                    description
                      "Static MAC addresses";
                    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";
                    }
                  }  // list static-mac
                }  // list bridge-access-pw
              }  // container bridge-access-pws

              container bridge-domain-info {
                description
                  "Bridge Domain Information";
                container security-parameters {
                  description
                    "Security parameters";
                  container storm-control {
                    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";
                    }
                  }  // 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";
                  }
                }  // container security-parameters

                container pbb-parameters {
                  description
                    "PBB parameters";
                  container pbb-edge {
                    when
                      "../type = 'l2vpn-bridge-type-pbb-edge'" {
                      description
                        "../Type = 'L2VPN_BRIDGE_TYPE_PBB_EDGE'";
                    }
                    description "PBB Edge";
                    container edge-port {
                      description
                        "PBB Edge Port";
                      container security-parameters {
                        description
                          "Security Parameters";
                        container base {
                          description
                            "Basic Security Parameters";
                          container storm-control {
                            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";
                            }
                          }  // 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";
                          }
                        }  // container base

                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container security-parameters

                      container statistics {
                        description
                          "Statistics";
                        container imposition-stats {
                          description
                            "imposition stats";
                          container imposition-stat {
                            description
                              "imposition stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-stat

                          container imposition-mtu-drop {
                            description
                              "imposition mtu drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-mtu-drop

                          container imposition-tail-drop {
                            description
                              "imposition tail drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container imposition-tail-drop

                          container l2fsbi-drop {
                            description
                              "rx discards";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container l2fsbi-drop

                          container multicast {
                            description
                              "Multicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container multicast

                          container broadcast {
                            description
                              "Broadcast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container broadcast

                          container known-unicast {
                            description
                              "Known Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container known-unicast

                          container unknown-unicast {
                            description
                              "Unknown Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container unknown-unicast
                        }  // container imposition-stats

                        container disposition-stats {
                          description
                            "disposition stats";
                          container disposition-stat {
                            description
                              "disposition stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-stat

                          container disposition-mtu-drop {
                            description
                              "disposition mtu drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-mtu-drop

                          container disposition-tail-drop {
                            description
                              "disposition tail drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-tail-drop

                          container multicast-drop {
                            description
                              "disposition storm control multicast drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container multicast-drop

                          container unicast-drop {
                            description
                              "disposition storm control unknown unicast drop
stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container unicast-drop

                          container broadcast-drop {
                            description
                              "disposition storm control broadcast drop stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container broadcast-drop

                          container received-drops {
                            description
                              "tx discards";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container received-drops

                          container dai-drop {
                            description
                              "Disposition dynamic ARP inspection drop
statistics";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container dai-drop

                          container ipsg-drop {
                            description
                              "disposition IP source guard drop statistics";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container ipsg-drop

                          container disposition-oo-o-drops {
                            description
                              "Disposition Out-of-Order Drops";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-oo-o-drops

                          container disposition-p2mp-stats {
                            description
                              "Disposition P2MP Stats";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container disposition-p2mp-stats

                          container known-unicast {
                            description
                              "Known Unicast";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container known-unicast

                          container mac-move {
                            description
                              "MAC Move";
                            leaf packet-counts {
                              type uint64;
                              description
                                "packets counters";
                            }

                            leaf byte-counts {
                              type uint64;
                              units "byte";
                              description
                                "bytes counters";
                            }
                          }  // container mac-move
                        }  // container disposition-stats

                        container sequence-number {
                          description
                            "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";
                          }
                        }  // container sequence-number
                      }  // 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";
                        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";
                        }
                      }  // list bmac-mapping
                    }  // 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";
                    }
                  }  // container pbb-edge

                  container pbb-core {
                    when
                      "../type = 'l2vpn-bridge-type-pbb-core'" {
                      description
                        "../Type = 'L2VPN_BRIDGE_TYPE_PBB_CORE'";
                    }
                    description "PBB Core";
                    container core-port {
                      description
                        "PBB Core Port";
                      container security-parameters {
                        description
                          "Security Parameters";
                        container base {
                          description
                            "Basic Security Parameters";
                          container storm-control {
                            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";
                            }
                          }  // 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";
                          }
                        }  // container base

                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // 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";
                      }
                    }  // container core-port

                    leaf num-ass-edge {
                      type uint32;
                      description
                        "Number of Associated PBB Edges";
                    }
                  }  // container pbb-core

                  leaf type {
                    type L2vpn-bridge;
                    description "Type";
                  }
                }  // container pbb-parameters

                container evpn-parameters {
                  description
                    "EVPN parameters";
                  container evpn-port {
                    description "EVPN Port";
                    container security-parameters {
                      description
                        "Security Parameters";
                      container base {
                        description
                          "Basic Security Parameters";
                        container storm-control {
                          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";
                          }
                        }  // 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";
                        }
                      }  // container base

                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container security-parameters

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    leaf xconnect-id {
                      type uint32;
                      description
                        "Xconnect ID";
                    }

                    leaf evpn-port-state {
                      type L2vpn-virtualport-state;
                      description
                        "EVPN Port State";
                    }
                  }  // container evpn-port

                  leaf evi {
                    type uint32;
                    description "E-VPN id";
                  }
                }  // container evpn-parameters

                container vni-parameters {
                  description
                    "VNI parameters";
                  container security-parameters {
                    description
                      "Security Parameters";
                    container base {
                      description
                        "Basic Security Parameters";
                      container storm-control {
                        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";
                        }
                      }  // 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";
                      }
                    }  // container base

                    container storm-control {
                      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";
                      }
                    }  // 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";
                    }
                  }  // container security-parameters

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // 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";
                    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";
                    }
                  }  // list static-mac
                }  // container vni-parameters

                container rd {
                  description
                    "Route Distinguisher";
                  container auto {
                    when
                      "../rd = 'l2vpn-ad-rd-auto'" {
                      description
                        "../RD = 'L2VPN_AD_RD_AUTO'";
                    }
                    description "auto";
                    leaf router-id {
                      type inet:ipv4-address;
                      description
                        "BGP Router ID";
                    }

                    leaf auto-index {
                      type uint16;
                      description
                        "Auto-generated Index";
                    }
                  }  // container auto

                  container two-byte-as {
                    when
                      "../rd = 'l2vpn-ad-rd-as'" {
                      description
                        "../RD = 'L2VPN_AD_RD_AS'";
                    }
                    description
                      "two byte as";
                    leaf two-byte-as {
                      type uint16;
                      description
                        "2 Byte AS Number";
                    }

                    leaf four-byte-index {
                      type uint32;
                      description
                        "4 Byte Index";
                    }
                  }  // 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";
                    leaf four-byte-as {
                      type uint32;
                      description
                        "4 Byte AS Number";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container four-byte-as

                  container v4-addr {
                    when
                      "../rd = 'l2vpn-ad-rd-v4-addr'" {
                      description
                        "../RD = 'L2VPN_AD_RD_V4ADDR'";
                    }
                    description "v4 addr";
                    leaf ipv4-address {
                      type inet:ipv4-address;
                      description
                        "IPv4 Address";
                    }

                    leaf two-byte-index {
                      type uint16;
                      description
                        "2 Byte Index";
                    }
                  }  // container v4-addr

                  leaf rd {
                    type L2vpn-ad-rd;
                    description "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";
                  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";
                  }
                }  // list mac-filter

                list bridge-vfi {
                  description
                    "Virtual Forwarding Interfaces";
                  container discovery-information {
                    description
                      "Auto Discovery information";
                    container rd-value {
                      description
                        "Route Distinguisher";
                      container auto {
                        when
                          "../rd = 'l2vpn-ad-rd-auto'" {
                          description
                            "../RD = 'L2VPN_AD_RD_AUTO'";
                        }
                        description "auto";
                        leaf router-id {
                          type inet:ipv4-address;
                          description
                            "BGP Router ID";
                        }

                        leaf auto-index {
                          type uint16;
                          description
                            "Auto-generated Index";
                        }
                      }  // container auto

                      container two-byte-as {
                        when
                          "../rd = 'l2vpn-ad-rd-as'" {
                          description
                            "../RD = 'L2VPN_AD_RD_AS'";
                        }
                        description
                          "two byte as";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf four-byte-as {
                          type uint32;
                          description
                            "4 Byte AS Number";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container four-byte-as

                      container v4-addr {
                        when
                          "../rd = 'l2vpn-ad-rd-v4-addr'" {
                          description
                            "../RD = 'L2VPN_AD_RD_V4ADDR'";
                        }
                        description
                          "v4 addr";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf rd {
                        type L2vpn-ad-rd;
                        description "RD";
                      }
                    }  // container rd-value

                    container vpls-id {
                      description "VPLS ID";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // 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";
                      container two-byte-as {
                        when
                          "../rt = 'l2vpn-ad-rt-as'" {
                          description
                            "../RT = 'L2VPN_AD_RT_AS'";
                        }
                        description
                          "two byte as";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf four-byte-as {
                          type uint32;
                          description
                            "4 Byte AS Number";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container four-byte-as

                      container v4-addr {
                        when
                          "../rt = 'l2vpn-ad-rt-v4-addr'" {
                          description
                            "../RT = 'L2VPN_AD_RT_V4ADDR'";
                        }
                        description
                          "v4 addr";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      container es-import {
                        when
                          "../rt = 'es-import'" {
                          description
                            "../RT = 'ES_Import'";
                        }
                        description
                          "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";
                        }
                      }  // container es-import

                      leaf rt {
                        type L2vpn-ad-rt;
                        description "RT";
                      }
                    }  // list import-rt

                    list export-rt {
                      description
                        "List of export route targets";
                      container two-byte-as {
                        when
                          "../rt = 'l2vpn-ad-rt-as'" {
                          description
                            "../RT = 'L2VPN_AD_RT_AS'";
                        }
                        description
                          "two byte as";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf four-byte-as {
                          type uint32;
                          description
                            "4 Byte AS Number";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container four-byte-as

                      container v4-addr {
                        when
                          "../rt = 'l2vpn-ad-rt-v4-addr'" {
                          description
                            "../RT = 'L2VPN_AD_RT_V4ADDR'";
                        }
                        description
                          "v4 addr";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      container es-import {
                        when
                          "../rt = 'es-import'" {
                          description
                            "../RT = 'ES_Import'";
                        }
                        description
                          "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";
                        }
                      }  // container es-import

                      leaf rt {
                        type L2vpn-ad-rt;
                        description "RT";
                      }
                    }  // list export-rt
                  }  // 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";
                    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";
                    }
                  }  // list p2mp-information
                }  // list bridge-vfi

                list bridge-access-vfi {
                  description
                    "Access Virtual Forwarding Interfaces";
                  container discovery-information {
                    description
                      "Auto Discovery information";
                    container rd-value {
                      description
                        "Route Distinguisher";
                      container auto {
                        when
                          "../rd = 'l2vpn-ad-rd-auto'" {
                          description
                            "../RD = 'L2VPN_AD_RD_AUTO'";
                        }
                        description "auto";
                        leaf router-id {
                          type inet:ipv4-address;
                          description
                            "BGP Router ID";
                        }

                        leaf auto-index {
                          type uint16;
                          description
                            "Auto-generated Index";
                        }
                      }  // container auto

                      container two-byte-as {
                        when
                          "../rd = 'l2vpn-ad-rd-as'" {
                          description
                            "../RD = 'L2VPN_AD_RD_AS'";
                        }
                        description
                          "two byte as";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf four-byte-as {
                          type uint32;
                          description
                            "4 Byte AS Number";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container four-byte-as

                      container v4-addr {
                        when
                          "../rd = 'l2vpn-ad-rd-v4-addr'" {
                          description
                            "../RD = 'L2VPN_AD_RD_V4ADDR'";
                        }
                        description
                          "v4 addr";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf rd {
                        type L2vpn-ad-rd;
                        description "RD";
                      }
                    }  // container rd-value

                    container vpls-id {
                      description "VPLS ID";
                      container auto {
                        when
                          "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                          description
                            "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                        }
                        description "auto";
                        leaf asn {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf vpn-id {
                          type uint32;
                          description
                            "VPN ID";
                        }
                      }  // 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";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      leaf vpls-id-type {
                        type L2vpn-ad-vpls-id;
                        description
                          "VPLS ID TYPE";
                      }
                    }  // 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";
                      container two-byte-as {
                        when
                          "../rt = 'l2vpn-ad-rt-as'" {
                          description
                            "../RT = 'L2VPN_AD_RT_AS'";
                        }
                        description
                          "two byte as";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf four-byte-as {
                          type uint32;
                          description
                            "4 Byte AS Number";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container four-byte-as

                      container v4-addr {
                        when
                          "../rt = 'l2vpn-ad-rt-v4-addr'" {
                          description
                            "../RT = 'L2VPN_AD_RT_V4ADDR'";
                        }
                        description
                          "v4 addr";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      container es-import {
                        when
                          "../rt = 'es-import'" {
                          description
                            "../RT = 'ES_Import'";
                        }
                        description
                          "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";
                        }
                      }  // container es-import

                      leaf rt {
                        type L2vpn-ad-rt;
                        description "RT";
                      }
                    }  // list import-rt

                    list export-rt {
                      description
                        "List of export route targets";
                      container two-byte-as {
                        when
                          "../rt = 'l2vpn-ad-rt-as'" {
                          description
                            "../RT = 'L2VPN_AD_RT_AS'";
                        }
                        description
                          "two byte as";
                        leaf two-byte-as {
                          type uint16;
                          description
                            "2 Byte AS Number";
                        }

                        leaf four-byte-index {
                          type uint32;
                          description
                            "4 Byte Index";
                        }
                      }  // 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";
                        leaf four-byte-as {
                          type uint32;
                          description
                            "4 Byte AS Number";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container four-byte-as

                      container v4-addr {
                        when
                          "../rt = 'l2vpn-ad-rt-v4-addr'" {
                          description
                            "../RT = 'L2VPN_AD_RT_V4ADDR'";
                        }
                        description
                          "v4 addr";
                        leaf ipv4-address {
                          type inet:ipv4-address;
                          description
                            "IPv4 Address";
                        }

                        leaf two-byte-index {
                          type uint16;
                          description
                            "2 Byte Index";
                        }
                      }  // container v4-addr

                      container es-import {
                        when
                          "../rt = 'es-import'" {
                          description
                            "../RT = 'ES_Import'";
                        }
                        description
                          "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";
                        }
                      }  // container es-import

                      leaf rt {
                        type L2vpn-ad-rt;
                        description "RT";
                      }
                    }  // list export-rt
                  }  // 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";
                    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";
                    }
                  }  // list p2mp-information
                }  // list bridge-access-vfi
              }  // container bridge-domain-info

              leaf bridge-domain-group-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Bridge Domain Group Name";
              }

              leaf bridge-domain-name {
                type xr:Cisco-ios-xr-string {
                  length "1..27";
                }
                description
                  "Bridge Domain Name";
              }
            }  // list bridge-domain
          }  // container bridge-domains

          container discovery-summary {
            description
              "Discovery summary information";
            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";
            }
          }  // container discovery-summary

          container g8032 {
            description "G8032 information";
            container g8032-rings {
              description "G8032 Ring table";
              list g8032-ring {
                key "ring-name";
                description "G8032 Ring";
                container g8032-ring-detail {
                  description
                    "G8032 Ring detailed information";
                  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
                }  // container g8032-ring-detail

                container g8032-ring-instance-summaries {
                  description
                    "G8032 Ring Instance summary table";
                  list g8032-ring-instance-summary {
                    key "instance";
                    description
                      "G8032 Ring Instance summary information";
                    leaf instance {
                      type uint32;
                      description "Instance";
                    }

                    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
                  }  // list g8032-ring-instance-summary
                }  // container g8032-ring-instance-summaries

                container g8032-ring-summary {
                  description
                    "G8032 Ring summary information";
                  leaf ring-name {
                    type string;
                    description
                      "Name of the ring";
                  }

                  leaf port0 {
                    type string;
                    description "Port 0";
                  }

                  leaf port1 {
                    type string;
                    description "Port 1";
                  }
                }  // container g8032-ring-summary

                container g8032-ring-instance-details {
                  description
                    "G8032 Ring Instance detail table";
                  list g8032-ring-instance-detail {
                    key "instance";
                    description
                      "G8032 Ring Instance detailed information";
                    leaf instance {
                      type G8032-ring-instance-range;
                      description "Instance";
                    }

                    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
                  }  // list g8032-ring-instance-detail
                }  // container g8032-ring-instance-details

                leaf ring-name {
                  type xr:Cisco-ios-xr-string {
                    length "1..32";
                  }
                  description "Ring Name";
                }
              }  // list g8032-ring
            }  // container g8032-rings
          }  // container g8032

          container pseudowire-classes {
            description
              "List of pseudowire classes";
            list pseudowire-class {
              key "pseudowire-class-name";
              description
                "Pseudowire class information";
              leaf pseudowire-class-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Pseudowire Class Name";
              }

              container encapsulation-info {
                description
                  "Encapsulation specific pseudowire information";
                container l2tpv3 {
                  when
                    "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                    description
                      "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                  }
                  description "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 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";
                  }
                }  // container l2tpv3

                leaf encapsulation {
                  type L2vpn-encap-method;
                  description
                    "Encapsulation";
                }
              }  // container encapsulation-info

              container preferred-path {
                description
                  "MPLS Preferred Path";
                container srte-policy {
                  when
                    "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                    description
                      "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                  }
                  description "srte policy";
                  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";
                  }
                }  // 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";
                  leaf te-named-tunnel {
                    type string;
                    description
                      "TE Tunnel Name";
                  }
                }  // 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";
                }
              }  // container preferred-path

              container local-source-address {
                description
                  "Local 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";
                }
              }  // 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";
              }
            }  // list pseudowire-class
          }  // container pseudowire-classes

          container l2vpn-collaborators {
            description
              "L2VPN collaborator information";
            container collaborator-statistics {
              description
                "Collaborator Statistics";
              list count {
                max-elements 1;
                description "count";
                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";
                }
              }  // list count
            }  // container collaborator-statistics
          }  // container l2vpn-collaborators

          container mvrp {
            description "MVRP";
            container mvrp-main-ports {
              description
                "MVRP Main Port Table";
              list mvrp-main-port {
                key "main-port-interface-name";
                description "MVRP Main Port";
                container mvrp-main-port-info {
                  description
                    "MVRP Main Port Information";
                  container default-bridge-port {
                    description
                      "Trunk or default Bridge Port";
                    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";
                      leaf lower {
                        type uint16;
                        description "Lower";
                      }

                      leaf upper {
                        type uint16;
                        description "Upper";
                      }
                    }  // list vlan-range
                  }  // 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";
                  }
                }  // container mvrp-main-port-info

                container mvrp-bridge-ports {
                  description
                    "MVRP Bridge Port Table";
                  list mvrp-bridge-port {
                    key "interface-name";
                    description
                      "MVRP Bridge Port Information";
                    leaf interface-name {
                      type xr:Interface-name;
                      description
                        "Bridge Port Interface Name";
                    }

                    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";
                      leaf lower {
                        type uint16;
                        description "Lower";
                      }

                      leaf upper {
                        type uint16;
                        description "Upper";
                      }
                    }  // list vlan-range
                  }  // list mvrp-bridge-port
                }  // container mvrp-bridge-ports

                leaf main-port-interface-name {
                  type xr:Interface-name;
                  description
                    "Main Port interface";
                }
              }  // list mvrp-main-port
            }  // container mvrp-main-ports
          }  // container mvrp

          container generic-interface-lists {
            description
              "L2VPN generic interface list Table";
            list generic-interface-list {
              key "interface-list-name";
              description
                "Generic Interface List information";
              leaf interface-list-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Generic Interface List Name";
              }

              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";
                leaf interface-name {
                  type string;
                  description
                    "Interface name";
                }

                leaf pending-replications {
                  type uint32;
                  description
                    "Number of pending replications";
                }

                leaf not-supported-replications {
                  type uint32;
                  description
                    "Number of replications failed because
unsupported";
                }

                leaf is-fib-downloaded {
                  type boolean;
                  description
                    "Is interface downloaded to FIB";
                }
              }  // list interface
            }  // list generic-interface-list
          }  // container generic-interface-lists

          container mstp-vlans {
            description
              "L2VPN MSTP VLAN Table";
            list mstp-vlan {
              key "vlan-id";
              description
                "L2VPN MSTP VLAN information";
              leaf vlan-id {
                type uint32 {
                  range "0..4098";
                }
                description "vlan id";
              }

              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";
                leaf interface-name {
                  type string;
                  description
                    "Interface name";
                }
              }  // list sub-interface
            }  // list mstp-vlan
          }  // container mstp-vlans

          container l2vpn-pbb-bsa {
            description
              "L2VPN PBB Backbone Source MAC information";
            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";
            }
          }  // container l2vpn-pbb-bsa

          container flexible-xconnect-services {
            description
              "Flexible XConnect Service Table";
            list flexible-xconnect-service {
              key "name";
              description
                "Flexible XConnect Service Information";
              container flexible-xconnect-service-acs {
                description
                  "Flexible XConnect Service Attachment Circuit
Table";
                list flexible-xconnect-service-ac {
                  key "interface-name";
                  description
                    "Flexible XConnect Service Attachment Circuit";
                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Interface Name";
                  }

                  container attachment-circuit {
                    description
                      "Flexible XConnect Service Attachment Circuit";
                    container interface {
                      description
                        "Interface";
                      container parameters {
                        description
                          "Interface parameters";
                        container ethernet {
                          when
                            "../type = 'l2vpn-intf-type-ethernet'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                          }
                          description
                            "Ethernet";
                          leaf xconnect-tags {
                            type uint8;
                            description
                              "XConnect tags";
                          }
                        }  // container ethernet

                        container vlan {
                          when
                            "../type = 'l2vpn-intf-type-vlan'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                          }
                          description "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";
                            leaf lower {
                              type uint16;
                              description
                                "Lower";
                            }

                            leaf upper {
                              type uint16;
                              description
                                "Upper";
                            }
                          }  // list vlan-range
                        }  // container vlan

                        container tdm {
                          when
                            "../type = 'l2vpn-intf-type-cem'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_CEM'";
                          }
                          description "TDM";
                          container tdm-options {
                            description
                              "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";
                            }
                          }  // 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";
                          }
                        }  // container tdm

                        container atm {
                          when
                            "../type = 'l2vpn-intf-type-atm'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_ATM'";
                          }
                          description "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";
                          }
                        }  // container atm

                        container fr {
                          when
                            "../type = 'l2vpn-intf-type-frame-relay'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                          }
                          description
                            "Frame Relay";
                          leaf fr-mode {
                            type L2vpn-fr-mode;
                            description
                              "Frame Relay mode";
                          }

                          leaf dlci {
                            type uint32;
                            description
                              "Data-link connection identifier";
                          }
                        }  // container fr

                        container pseudowire-ether {
                          when
                            "../type = 'l2vpn-intf-type-pw-ether'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                          }
                          description
                            "PW Ether";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-ether

                        container pseudowire-iw {
                          when
                            "../type = 'l2vpn-intf-type-pw-iw'" {
                            description
                              "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                          }
                          description
                            "PW IW";
                          container interface-list {
                            description
                              "Interface list data";
                            leaf interface-list-name {
                              type string {
                                length
                                  "0..33";
                              }
                              description
                                "Interface-list name";
                            }

                            leaf interface-list-id {
                              type uint32;
                              description
                                "Interface internal ID";
                            }

                            list interface {
                              max-elements
                                32;
                              description
                                "Interfaces";
                              leaf interface-name {
                                type string;
                                description
                                  "Interface name";
                              }

                              leaf replicate-status {
                                type Iflist-rep-status;
                                description
                                  "Replicate status";
                              }
                            }  // list interface
                          }  // container interface-list

                          leaf is-valid {
                            type boolean;
                            description
                              "Is this Interface list valid";
                          }

                          leaf internal-label {
                            type uint32;
                            description
                              "Internal Label";
                          }
                        }  // container pseudowire-iw

                        leaf type {
                          type L2vpn-interface;
                          description "Type";
                        }
                      }  // 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";
                      }
                    }  // container interface

                    container statistics {
                      description
                        "Statistics";
                      container imposition-stats {
                        description
                          "imposition stats";
                        container imposition-stat {
                          description
                            "imposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-stat

                        container imposition-mtu-drop {
                          description
                            "imposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-mtu-drop

                        container imposition-tail-drop {
                          description
                            "imposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container imposition-tail-drop

                        container l2fsbi-drop {
                          description
                            "rx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container l2fsbi-drop

                        container multicast {
                          description
                            "Multicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast

                        container broadcast {
                          description
                            "Broadcast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container unknown-unicast {
                          description
                            "Unknown Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unknown-unicast
                      }  // container imposition-stats

                      container disposition-stats {
                        description
                          "disposition stats";
                        container disposition-stat {
                          description
                            "disposition stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-stat

                        container disposition-mtu-drop {
                          description
                            "disposition mtu drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-mtu-drop

                        container disposition-tail-drop {
                          description
                            "disposition tail drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-tail-drop

                        container multicast-drop {
                          description
                            "disposition storm control multicast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container multicast-drop

                        container unicast-drop {
                          description
                            "disposition storm control unknown unicast drop
stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container unicast-drop

                        container broadcast-drop {
                          description
                            "disposition storm control broadcast drop stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container broadcast-drop

                        container received-drops {
                          description
                            "tx discards";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container received-drops

                        container dai-drop {
                          description
                            "Disposition dynamic ARP inspection drop
statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container dai-drop

                        container ipsg-drop {
                          description
                            "disposition IP source guard drop statistics";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container ipsg-drop

                        container disposition-oo-o-drops {
                          description
                            "Disposition Out-of-Order Drops";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-oo-o-drops

                        container disposition-p2mp-stats {
                          description
                            "Disposition P2MP Stats";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container disposition-p2mp-stats

                        container known-unicast {
                          description
                            "Known Unicast";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container known-unicast

                        container mac-move {
                          description
                            "MAC Move";
                          leaf packet-counts {
                            type uint64;
                            description
                              "packets counters";
                          }

                          leaf byte-counts {
                            type uint64;
                            units "byte";
                            description
                              "bytes counters";
                          }
                        }  // container mac-move
                      }  // container disposition-stats

                      container sequence-number {
                        description
                          "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";
                        }
                      }  // container sequence-number
                    }  // container statistics

                    container l2vpn-protection {
                      description
                        "Protection object used for this segment";
                      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";
                      }
                    }  // 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";
                    }
                  }  // container attachment-circuit
                }  // list flexible-xconnect-service-ac
              }  // container flexible-xconnect-service-acs

              container flexible-xconnect-service-info {
                description
                  "Flexible XConnect Service Information";
                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";
                  container peer-id {
                    description "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";
                    }
                  }  // container peer-id

                  container encapsulation-info {
                    description
                      "Encapsulation specific pseudowire information";
                    container atom {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-mpls'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_MPLS'";
                      }
                      description "atom";
                      container local-agi {
                        description
                          "Local Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container local-agi

                      container remote-agi {
                        description
                          "Remote Attachment Group Identifier";
                        container auto {
                          when
                            "../vpls-id-type = 'l2vpn-ad-vpls-id-auto'" {
                            description
                              "../VPLS_ID_TYPE = 'L2VPN_AD_VPLS_ID_AUTO'";
                          }
                          description "auto";
                          leaf asn {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf vpn-id {
                            type uint32;
                            description
                              "VPN ID";
                          }
                        }  // 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";
                          leaf two-byte-as {
                            type uint16;
                            description
                              "2 Byte AS Number";
                          }

                          leaf four-byte-index {
                            type uint32;
                            description
                              "4 Byte Index";
                          }
                        }  // 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";
                          leaf ipv4-address {
                            type inet:ipv4-address;
                            description
                              "IPv4 Address";
                          }

                          leaf two-byte-index {
                            type uint16;
                            description
                              "2 Byte Index";
                          }
                        }  // container v4-addr

                        leaf vpls-id-type {
                          type L2vpn-ad-vpls-id;
                          description
                            "VPLS ID TYPE";
                        }
                      }  // container remote-agi

                      container multi-segment-pseudowire-stats {
                        description
                          "Multisegment pseudowire statistics";
                        leaf received-packets {
                          type uint64;
                          description
                            "Packets received";
                        }

                        leaf received-bytes {
                          type uint64;
                          units "byte";
                          description
                            "Bytes received";
                        }
                      }  // 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";
                      }
                    }  // container atom

                    container l2tpv3 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-l2tpv3'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_L2TPV3'";
                      }
                      description "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";
                      }
                    }  // container l2tpv3

                    container srv6 {
                      when
                        "../encapsulation = 'l2vpn-pw-encaps-srv6'" {
                        description
                          "../Encapsulation = 'L2VPN_PW_ENCAPS_SRV6'";
                      }
                      description "srv6";
                      container srv6-headend-behavior {
                        description
                          "Headend behavior in use";
                        leaf type {
                          type Mgmt-srv6-headend;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // container srv6-headend-behavior

                      container srv6-endpoint-behavior {
                        description
                          "Endpoint behavior in use";
                        leaf type {
                          type Mgmt-srv6-endpoint;
                          description
                            "Behavior type";
                        }

                        leaf description {
                          type string;
                          description
                            "Behavior description";
                        }
                      }  // 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";
                        container sr-te-info {
                          description
                            "SR(v6)-TE Policy info from ODN";
                          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";
                          }
                        }  // container sr-te-info

                        container layer2-attributes {
                          description
                            "Layer 2 Attributes";
                          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";
                          }
                        }  // 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";
                          leaf srv6-sid {
                            type inet:ipv6-address;
                            description
                              "SRv6 SID";
                          }
                        }  // list srv6-sid-info
                      }  // list remote-path-buffer
                    }  // container srv6

                    leaf encapsulation {
                      type L2vpn-encap-method;
                      description
                        "Encapsulation";
                    }
                  }  // container encapsulation-info

                  container local-interface {
                    description
                      "Local interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

                          leaf interface-list-id {
                            type uint32;
                            description
                              "Interface internal ID";
                          }

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

                        leaf is-valid {
                          type boolean;
                          description
                            "Is this Interface list valid";
                        }

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

                          leaf interface-list-id {
                            type uint32;
                            description
                              "Interface internal ID";
                          }

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

                        leaf is-valid {
                          type boolean;
                          description
                            "Is this Interface list valid";
                        }

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container local-interface

                  container remote-interface {
                    description
                      "Remote interface";
                    container parameters {
                      description
                        "Interface parameters";
                      container ethernet {
                        when
                          "../type = 'l2vpn-intf-type-ethernet'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ETHERNET'";
                        }
                        description
                          "Ethernet";
                        leaf xconnect-tags {
                          type uint8;
                          description
                            "XConnect tags";
                        }
                      }  // container ethernet

                      container vlan {
                        when
                          "../type = 'l2vpn-intf-type-vlan'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_VLAN'";
                        }
                        description "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";
                          leaf lower {
                            type uint16;
                            description
                              "Lower";
                          }

                          leaf upper {
                            type uint16;
                            description
                              "Upper";
                          }
                        }  // list vlan-range
                      }  // container vlan

                      container tdm {
                        when
                          "../type = 'l2vpn-intf-type-cem'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_CEM'";
                        }
                        description "TDM";
                        container tdm-options {
                          description
                            "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";
                          }
                        }  // 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";
                        }
                      }  // container tdm

                      container atm {
                        when
                          "../type = 'l2vpn-intf-type-atm'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_ATM'";
                        }
                        description "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";
                        }
                      }  // container atm

                      container fr {
                        when
                          "../type = 'l2vpn-intf-type-frame-relay'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_FRAME_RELAY'";
                        }
                        description
                          "Frame Relay";
                        leaf fr-mode {
                          type L2vpn-fr-mode;
                          description
                            "Frame Relay mode";
                        }

                        leaf dlci {
                          type uint32;
                          description
                            "Data-link connection identifier";
                        }
                      }  // container fr

                      container pseudowire-ether {
                        when
                          "../type = 'l2vpn-intf-type-pw-ether'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_ETHER'";
                        }
                        description
                          "PW Ether";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

                          leaf interface-list-id {
                            type uint32;
                            description
                              "Interface internal ID";
                          }

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

                        leaf is-valid {
                          type boolean;
                          description
                            "Is this Interface list valid";
                        }

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-ether

                      container pseudowire-iw {
                        when
                          "../type = 'l2vpn-intf-type-pw-iw'" {
                          description
                            "../Type = 'L2VPN_INTF_TYPE_PW_IW'";
                        }
                        description "PW IW";
                        container interface-list {
                          description
                            "Interface list data";
                          leaf interface-list-name {
                            type string {
                              length "0..33";
                            }
                            description
                              "Interface-list name";
                          }

                          leaf interface-list-id {
                            type uint32;
                            description
                              "Interface internal ID";
                          }

                          list interface {
                            max-elements
                              32;
                            description
                              "Interfaces";
                            leaf interface-name {
                              type string;
                              description
                                "Interface name";
                            }

                            leaf replicate-status {
                              type Iflist-rep-status;
                              description
                                "Replicate status";
                            }
                          }  // list interface
                        }  // container interface-list

                        leaf is-valid {
                          type boolean;
                          description
                            "Is this Interface list valid";
                        }

                        leaf internal-label {
                          type uint32;
                          description
                            "Internal Label";
                        }
                      }  // container pseudowire-iw

                      leaf type {
                        type L2vpn-interface;
                        description "Type";
                      }
                    }  // 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";
                    }
                  }  // container remote-interface

                  container preferred-path {
                    description
                      "MPLS Preferred Path";
                    container srte-policy {
                      when
                        "../option = 'l2vpn-pw-mpls-pref-path-sr-te'" {
                        description
                          "../Option = 'L2VPN_PW_MPLS_PREFPATH_SR_TE'";
                      }
                      description
                        "srte policy";
                      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";
                      }
                    }  // 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";
                      leaf te-named-tunnel {
                        type string;
                        description
                          "TE Tunnel Name";
                      }
                    }  // 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";
                    }
                  }  // container preferred-path

                  container local-signalling {
                    description
                      "Local signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

                    leaf pw-status {
                      type uint32;
                      description
                        "PW Status";
                    }

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container local-signalling

                  container remote-signalling {
                    description
                      "Remote signalling";
                    container status-tlv {
                      description
                        "PW Status Switching TLV";
                      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";
                      }
                    }  // container status-tlv

                    leaf pw-status {
                      type uint32;
                      description
                        "PW Status";
                    }

                    list tlv {
                      description
                        "Switching 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";
                      }
                    }  // list tlv
                  }  // container remote-signalling

                  container statistics {
                    description "Statistics";
                    container imposition-stats {
                      description
                        "imposition stats";
                      container imposition-stat {
                        description
                          "imposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-stat

                      container imposition-mtu-drop {
                        description
                          "imposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-mtu-drop

                      container imposition-tail-drop {
                        description
                          "imposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container imposition-tail-drop

                      container l2fsbi-drop {
                        description
                          "rx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container l2fsbi-drop

                      container multicast {
                        description
                          "Multicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast

                      container broadcast {
                        description
                          "Broadcast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container unknown-unicast {
                        description
                          "Unknown Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unknown-unicast
                    }  // container imposition-stats

                    container disposition-stats {
                      description
                        "disposition stats";
                      container disposition-stat {
                        description
                          "disposition stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-stat

                      container disposition-mtu-drop {
                        description
                          "disposition mtu drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-mtu-drop

                      container disposition-tail-drop {
                        description
                          "disposition tail drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-tail-drop

                      container multicast-drop {
                        description
                          "disposition storm control multicast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container multicast-drop

                      container unicast-drop {
                        description
                          "disposition storm control unknown unicast drop
stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container unicast-drop

                      container broadcast-drop {
                        description
                          "disposition storm control broadcast drop stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container broadcast-drop

                      container received-drops {
                        description
                          "tx discards";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container received-drops

                      container dai-drop {
                        description
                          "Disposition dynamic ARP inspection drop
statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container dai-drop

                      container ipsg-drop {
                        description
                          "disposition IP source guard drop statistics";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container ipsg-drop

                      container disposition-oo-o-drops {
                        description
                          "Disposition Out-of-Order Drops";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-oo-o-drops

                      container disposition-p2mp-stats {
                        description
                          "Disposition P2MP Stats";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container disposition-p2mp-stats

                      container known-unicast {
                        description
                          "Known Unicast";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container known-unicast

                      container mac-move {
                        description
                          "MAC Move";
                        leaf packet-counts {
                          type uint64;
                          description
                            "packets counters";
                        }

                        leaf byte-counts {
                          type uint64;
                          units "byte";
                          description
                            "bytes counters";
                        }
                      }  // container mac-move
                    }  // container disposition-stats

                    container sequence-number {
                      description
                        "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";
                      }
                    }  // container sequence-number
                  }  // container statistics

                  container p2mp-pw {
                    description
                      "P2MP Pseudowire Information";
                    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)";
                    }
                  }  // 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
                }  // list pseudowire
              }  // container flexible-xconnect-service-info

              leaf name {
                type xr:Cisco-ios-xr-string {
                  length "1..23";
                }
                description
                  "Flexible XConnect Service Name";
              }
            }  // list flexible-xconnect-service
          }  // container flexible-xconnect-services

          container xconnect-brief {
            description
              "XConnect brief information";
            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";
              list ac1 {
                description
                  "Array of l2vpn_xc_brief_first layer indexed by
the AC1 encapsulation type";
                list ac2 {
                  description
                    "Array of l2vpn_xc_brief_line indexed by the AC2
encapsulation type plus one type for PW";
                  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
                }  // list ac2
              }  // list ac1
            }  // list encapsulation-report-matrix

            list encapsulation-total {
              max-elements 4;
              description "Total summary";
              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
            }  // list encapsulation-total
          }  // container xconnect-brief
        }  // list node
      }  // container nodes
    }  // container l2vpnv2

    container generic-interface-list-v2 {
      config false;
      description
        "Generic Interface List operational data";
      container nodes {
        description
          "Table of generic interface list operational data
         for a particular node";
        list node {
          key "node-id";
          description
            "Generic interface list operational data for a
           particular node";
          leaf node-id {
            type xr:Node-id;
            description "Location";
          }

          container generic-interface-lists {
            description
              "Generic interface list table";
            list generic-interface-list {
              key "generic-interface-list-name";
              description
                "Generic Interface List";
              leaf generic-interface-list-name {
                type xr:Cisco-ios-xr-string {
                  length "1..32";
                }
                description
                  "Generic Interface List Name";
              }

              leaf interface-list-name {
                type string {
                  length "0..33";
                }
                description
                  "Interface-list name";
              }

              leaf interface-list-id {
                type uint32;
                description
                  "Interface internal ID";
              }

              leaf items {
                type uint32;
                description
                  "Number of items on which interface list is
replicated";
              }

              leaf is-provisioned {
                type boolean;
                description "Is Provisioned";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is Interface list downloaded to FIB";
              }

              list interface {
                description "Interfaces";
                leaf interface-name {
                  type string;
                  description
                    "Interface name";
                }

                leaf pending-replications {
                  type uint32;
                  description
                    "Number of pending replications";
                }

                leaf not-supported-replications {
                  type uint32;
                  description
                    "Number of replications failed because
unsupported";
                }

                leaf is-fib-downloaded {
                  type boolean;
                  description
                    "Is interface downloaded to FIB";
                }
              }  // list interface
            }  // list generic-interface-list
          }  // container generic-interface-lists
        }  // list node
      }  // container nodes

      container standby {
        description
          "Standby generic interface list operational data";
        container generic-interface-lists {
          description
            "Generic interface list table";
          list generic-interface-list {
            key "generic-interface-list-name";
            description
              "Generic Interface List";
            leaf generic-interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Generic Interface List Name";
            }

            leaf interface-list-name {
              type string {
                length "0..33";
              }
              description
                "Interface-list name";
            }

            leaf interface-list-id {
              type uint32;
              description
                "Interface internal ID";
            }

            leaf items {
              type uint32;
              description
                "Number of items on which interface list is
replicated";
            }

            leaf is-provisioned {
              type boolean;
              description "Is Provisioned";
            }

            leaf is-fib-downloaded {
              type boolean;
              description
                "Is Interface list downloaded to FIB";
            }

            list interface {
              description "Interfaces";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf pending-replications {
                type uint32;
                description
                  "Number of pending replications";
              }

              leaf not-supported-replications {
                type uint32;
                description
                  "Number of replications failed because
unsupported";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is interface downloaded to FIB";
              }
            }  // list interface
          }  // list generic-interface-list
        }  // container generic-interface-lists
      }  // container standby

      container active {
        description
          "Active generic interface list operational data";
        container generic-interface-lists {
          description
            "Generic interface list table";
          list generic-interface-list {
            key "generic-interface-list-name";
            description
              "Generic Interface List";
            leaf generic-interface-list-name {
              type xr:Cisco-ios-xr-string {
                length "1..32";
              }
              description
                "Generic Interface List Name";
            }

            leaf interface-list-name {
              type string {
                length "0..33";
              }
              description
                "Interface-list name";
            }

            leaf interface-list-id {
              type uint32;
              description
                "Interface internal ID";
            }

            leaf items {
              type uint32;
              description
                "Number of items on which interface list is
replicated";
            }

            leaf is-provisioned {
              type boolean;
              description "Is Provisioned";
            }

            leaf is-fib-downloaded {
              type boolean;
              description
                "Is Interface list downloaded to FIB";
            }

            list interface {
              description "Interfaces";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf pending-replications {
                type uint32;
                description
                  "Number of pending replications";
              }

              leaf not-supported-replications {
                type uint32;
                description
                  "Number of replications failed because
unsupported";
              }

              leaf is-fib-downloaded {
                type boolean;
                description
                  "Is interface downloaded to FIB";
              }
            }  // list interface
          }  // list generic-interface-list
        }  // container generic-interface-lists
      }  // container active
    }  // container generic-interface-list-v2
  }  // module Cisco-IOS-XR-l2vpn-oper