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

    yang-version 1;

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

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

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

    organization "Cisco Systems, Inc.";

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

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

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

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

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

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

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

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

    revision "2017-06-26" {
      description
        "Change identifiers to be more readable.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

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

    semver:module-version "4.0.0";
    semver:module-version "3.0.0";
    semver:module-version "2.0.0";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    typedef Evpn-vpws {
      type enumeration {
        enum "vlan-unaware" {
          value 0;
          description "VlanUnaware";
        }
        enum "vlan-aware" {
          value 1;
          description "VlanAware";
        }
      }
      description "EVPN VU/VA Types";
    }
  }  // submodule Cisco-IOS-XR-l2vpn-oper-sub2