submodule Cisco-IOS-XR-evpn-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-evpn-oper {
        prefix Cisco-IOS-XR-evpn-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;
    }

    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 evpn 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
       2020-04-02
         EVPN DF Election Synchronization with NTP related changes";
    }

    revision "2019-12-20" {
      description
        "EVPN SRv6 related changes";
    }

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

    revision "2018-09-26" {
      description
        "Duplicate detection parameters config moved from l2vpn to l2rib.";
    }

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

    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-evpn-es-access-signal-mode {
      type enumeration {
        enum "unsupported" {
          value 0;
          description
            "Unsupported interface type";
        }
        enum "oos" {
          value 1;
          description "Out of Sync";
        }
        enum "down" {
          value 2;
          description "Down";
        }
      }
      description
        "L2vpn evpn es access signal mode";
    }

    typedef L2vpn-evpn-sc-mcast-mode {
      type enumeration {
        enum "disabled" {
          value 0;
          description
            "multicast service carving is disabled";
        }
        enum "hrw-s-g" {
          value 1;
          description "Multicast HRW S,G";
        }
        enum "hrw-g" {
          value 2;
          description "Multicast HRW *,G";
        }
      }
      description
        "EVPN Ethernet-Segment service multicast carving
       mode";
    }

    typedef L2vpn-evpn-sc-synchronization-mode {
      type enumeration {
        enum "none" {
          value 0;
          description
            "No service carving synchronization";
        }
        enum "ntp" {
          value 1;
          description
            "NTP SCT based service carving synchronization";
        }
        enum "handshake" {
          value 2;
          description
            "Handshake messaging based service carving
           synchronization";
        }
        enum "invalid" {
          value 3;
          description
            "Invalid or unknown service carving
           synchronization mode";
        }
      }
      description
        "EVPN Ethernet-Segment service carving
       synchronization mode";
    }

    typedef L2vpn-evpn-sc-mode {
      type enumeration {
        enum "invalid" {
          value 0;
          description
            "Invalid service carving mode";
        }
        enum "auto" {
          value 1;
          description
            "Auto service carving mode";
        }
        enum "manual" {
          value 2;
          description
            "Manual service carving";
        }
        enum "manual-list" {
          value 3;
          description
            "Manual List service carving";
        }
        enum "hrw" {
          value 4;
          description "HRW service carving";
        }
        enum "pref" {
          value 5;
          description
            "Preferential service carving";
        }
      }
      description
        "EVPN Ethernet-Segment service carving mode";
    }

    typedef L2vpn-evpn-smac-src {
      type enumeration {
        enum "invalid" {
          value 0;
          description
            "Incomplete Configuration";
        }
        enum "not-applicable" {
          value 1;
          description
            "Source MAC Not Applicable (EVPN)";
        }
        enum "local" {
          value 2;
          description "Local";
        }
        enum "pbb-bsa" {
          value 3;
          description "PBB BSA";
        }
        enum "esi" {
          value 4;
          description "From ESI";
        }
        enum "esi-invalid" {
          value 5;
          description "From ESI, Error";
        }
        enum "pbb-bsa-overrride" {
          value 6;
          description "PBB BSA, no ESI";
        }
      }
      description "L2vpn evpn smac src";
    }

    typedef L2vpn-evpn-lb-mode {
      type enumeration {
        enum "invalid-load-balancing" {
          value 0;
          description
            "Invalid load balancing";
        }
        enum "single-homed" {
          value 1;
          description
            "Single-homed site or network";
        }
        enum "multi-homed-aa-per-flow" {
          value 2;
          description
            "Multi-homed access network active/active per
           flow";
        }
        enum "multi-homed-aa-per-service" {
          value 3;
          description
            "Multi-homed access network active/active per
           service";
        }
        enum
          "multi-homed-single-flow-active" {
          value 4;
          description
            "Multi-homed access network single-flow-active";
        }
        enum "multi-homed-port-active" {
          value 5;
          description
            "Multi-homed access network port-active";
        }
      }
      description
        "L2VPN EVPN load balancing mode";
    }

    typedef L2vpn-evpn-mf-mode {
      type enumeration {
        enum "invalid" {
          value 0;
          description
            "Invalid MAC Flushing mode";
        }
        enum "tcn-stp" {
          value 1;
          description
            "TCN STP MAC Flushing mode";
        }
        enum "mvrp" {
          value 2;
          description
            "MVRP MAC Flushing mode";
        }
      }
      description
        "L2VPN EVPN MAC flushing mode";
    }

    typedef L2vpn-evpn-rt-origin {
      type enumeration {
        enum "invalid" {
          value 0;
          description
            "Incomplete Configuration";
        }
        enum "extracted" {
          value 1;
          description "From ESI";
        }
        enum "configured" {
          value 2;
          description "Locally configured";
        }
      }
      description "L2vpn evpn rt origin";
    }

    typedef L2vpn-rg-role {
      type enumeration {
        enum "l2vpn-rg-role-not-defined" {
          value 0;
          description
            "l2vpn rg role not defined";
        }
        enum "l2vpn-rg-role-active" {
          value 1;
          description "l2vpn rg role active";
        }
        enum "l2vpn-rg-role-standby" {
          value 2;
          description
            "l2vpn rg role standby";
        }
        enum "l2vpn-rg-role-max" {
          value 3;
          description "l2vpn rg role max";
        }
      }
      description "L2vpn rg role";
    }

    typedef L2vpn-evpn-es-state {
      type enumeration {
        enum "not-ready" {
          value 0;
          description "Not Ready";
        }
        enum "peering" {
          value 1;
          description "Peering";
        }
        enum "up" {
          value 2;
          description "Up";
        }
        enum "down" {
          value 3;
          description "Down";
        }
        enum "standby" {
          value 4;
          description "Standby";
        }
      }
      description "L2vpn evpn es state";
    }

    typedef L2vpn-evpn-esi {
      type enumeration {
        enum "esi-type0" {
          value 0;
          description "ESI type zero";
        }
        enum "esi-type1" {
          value 1;
          description "ESI type one";
        }
        enum "esi-type2" {
          value 2;
          description "ESI type two";
        }
        enum "esi-type3" {
          value 3;
          description "ESI type three";
        }
        enum "esi-type4" {
          value 4;
          description "ESI type four";
        }
        enum "esi-type5" {
          value 5;
          description "ESI type five";
        }
        enum "l2vpn-evpn-esi-type-legacy" {
          value 128;
          description "ESI type legacy";
        }
        enum "l2vpn-evpn-esi-type-override" {
          value 129;
          description
            "ESI type override (10-octet value)";
        }
        enum "esi-type-invalid" {
          value 255;
          description "ESI type invalid";
        }
      }
      description "EVPN ESI types";
    }

    typedef Evpn-bag-label-unresolved-reason {
      type enumeration {
        enum "none" {
          value 0;
          description "No reasons";
        }
        enum "no-evi-paths" {
          value 1;
          description
            "No valid per-EVI EAD paths";
        }
        enum "no-es-ead" {
          value 2;
          description "No per-ES EAD";
        }
        enum "local-not-ready" {
          value 3;
          description
            "Local service not ready, or multiple matching
           remote EADs";
        }
      }
      description
        "EVPN label entry unresolved reasons";
    }

    typedef L2vpn-ad-rt-role {
      type enumeration {
        enum "both" {
          value 0;
          description "Both";
        }
        enum "import" {
          value 1;
          description "Import";
        }
        enum "export" {
          value 2;
          description "Export";
        }
      }
      description "L2vpn ad rt role";
    }

    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 Evpn-pref-ecmp-nh-mode {
      type enumeration {
        enum "invalid" {
          value 0;
          description "Invalid";
        }
        enum "pref-nh-lowest-ip" {
          value 1;
          description
            "Preferred ECMP Nexthop Lowest IP";
        }
        enum "pref-nh-highest-ip" {
          value 2;
          description
            "Preferred ECMP Nexthop Highest IP";
        }
        enum "pref-nh-modulo" {
          value 3;
          description
            "Preferred ECMP Nexthop Modulo";
        }
        enum "ecmp-disable" {
          value 4;
          description "ECMP Disable";
        }
      }
      description "Evpn pref ecmp nh mode";
    }

    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-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-evpn {
      type enumeration {
        enum "evpn-type-invalid" {
          value 0;
          description
            "Unspecify type for that EVI entry";
        }
        enum "evpn-type-evpn" {
          value 1;
          description "EVPN service type";
        }
        enum "evpn-type-pbb-evpn" {
          value 2;
          description
            "PBB EVPN service type";
        }
        enum
          "evpn-type-evpn-vpws-vlan-unaware" {
          value 3;
          description
            "EVPN VPWS vlan-unaware service type";
        }
        enum
          "evpn-type-evpn-vpws-vlan-aware" {
          value 4;
          description
            "EVPN VPWS vlan-aware service type";
        }
        enum "evpn-type-max" {
          value 5;
          description "Max EVPN type";
        }
      }
      description "L2vpn evpn";
    }

    typedef Evpn-child {
      type enumeration {
        enum "l2-fwd" {
          value 0;
          description "L2 FWD";
        }
        enum "l3-sub-if" {
          value 1;
          description "L3 SUBIF";
        }
      }
      description "Evpn child";
    }

    typedef Evpn-igmp-grp {
      type enumeration {
        enum "include" {
          value 0;
          description "Include";
        }
        enum "exclude" {
          value 1;
          description "Exclude";
        }
      }
      description "Evpn igmp grp";
    }

    typedef Evpn-igmp-version {
      type enumeration {
        enum "v1" {
          value 0;
          description "Version 1";
        }
        enum "v2" {
          value 1;
          description "Version 2";
        }
        enum "v3" {
          value 2;
          description "Version 3";
        }
      }
      description "Evpn igmp version";
    }

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

    typedef Evpn-igmp-source {
      type enumeration {
        enum "local" {
          value 0;
          description "Local";
        }
        enum "remote" {
          value 1;
          description "Remote";
        }
      }
      description "Evpn igmp source";
    }

    typedef Evpn-igmp-msg {
      type enumeration {
        enum "join" {
          value 0;
          description "Join";
        }
        enum "leave" {
          value 1;
          description "Leave";
        }
      }
      description "Evpn igmp msg";
    }

    typedef Evpn-client1 {
      type enumeration {
        enum "igmpsn" {
          value 0;
          description "IGMPSN";
        }
        enum "igmp" {
          value 1;
          description "IGMP";
        }
        enum "mrib" {
          value 2;
          description "MRIB";
        }
        enum "mld" {
          value 3;
          description "MLD";
        }
        enum "invalid" {
          value 4;
          description "Invalid";
        }
      }
      description "Evpn client1";
    }

    typedef Im-state-enum {
      type enumeration {
        enum "im-state-not-ready" {
          value 0;
          description "im state not ready";
        }
        enum "im-state-admin-down" {
          value 1;
          description "im state admin down";
        }
        enum "im-state-down" {
          value 2;
          description "im state down";
        }
        enum "im-state-up" {
          value 3;
          description "im state up";
        }
        enum "im-state-shutdown" {
          value 4;
          description "im state shutdown";
        }
        enum "im-state-err-disable" {
          value 5;
          description "im state err disable";
        }
        enum "im-state-down-immediate" {
          value 6;
          description
            "im state down immediate";
        }
        enum "im-state-down-immediate-admin" {
          value 7;
          description
            "im state down immediate admin";
        }
        enum "im-state-down-graceful" {
          value 8;
          description
            "im state down graceful";
        }
        enum "im-state-begin-shutdown" {
          value 9;
          description
            "im state begin shutdown";
        }
        enum "im-state-end-shutdown" {
          value 10;
          description
            "im state end shutdown";
        }
        enum "im-state-begin-error-disable" {
          value 11;
          description
            "im state begin error disable";
        }
        enum "im-state-end-error-disable" {
          value 12;
          description
            "im state end error disable";
        }
        enum "im-state-begin-down-graceful" {
          value 13;
          description
            "im state begin down graceful";
        }
        enum "im-state-reset" {
          value 14;
          description "im state reset";
        }
        enum "im-state-operational" {
          value 15;
          description "im state operational";
        }
        enum "im-state-not-operational" {
          value 16;
          description
            "im state not operational";
        }
        enum "im-state-unknown" {
          value 17;
          description "im state unknown";
        }
        enum "im-state-last" {
          value 18;
          description "im state last";
        }
      }
      description "Im state enum";
    }

    typedef Evpn-grp {
      type enumeration {
        enum "deisolating" {
          value 0;
          description "Deisolating";
        }
        enum "isolated" {
          value 1;
          description "Isolated";
        }
        enum "ready" {
          value 2;
          description "Ready";
        }
        enum "incomplete" {
          value 3;
          description "Incomplete";
        }
      }
      description "EVPN Group State";
    }

    grouping L2VPN-ATOM-ACID {
      description "L2VPN ATOM ACID";
      leaf source-ac-id {
        type uint32;
        description "Source AC ID";
      }

      leaf target-ac-id {
        type uint32;
        description "Target AC ID";
      }

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

      leaf taii-global-id {
        type uint32;
        description "TAII Global ID";
      }

      leaf taii-ac-id {
        type uint32;
        description "TAII AC ID";
      }

      leaf taii-prefix {
        type inet:ipv6-address;
        description "TAII Prefix";
      }
    }  // grouping L2VPN-ATOM-ACID

    grouping L2VPN-EVPN-EAD-SERVICE-INFO {
      description
        "L2VPN EVPN EAD Ethernet Tag";
      leaf vpn-id {
        type uint32;
        description "VPN ID";
      }

      leaf type {
        type L2vpn-evpn;
        description "Service Type";
      }

      leaf ethernet-tag {
        type uint32;
        description "Ethernet Tag";
      }
    }  // grouping L2VPN-EVPN-EAD-SERVICE-INFO

    grouping L2VPN-BAG-TIMESPEC {
      description
        "L2VPN Timespec Data Structure";
      leaf tv-sec {
        type uint32;
        description "tv sec";
      }

      leaf tv-nsec {
        type uint32;
        description "tv nsec";
      }
    }  // grouping L2VPN-BAG-TIMESPEC

    grouping L2VPN-STAT-ITEM {
      description
        "L2VPN EVPN Ethernet Segment (ES) private stats
       item";
      container last-time {
        description "last time";
        uses L2VPN-BAG-TIMESPEC;
      }  // container last-time

      leaf count {
        type uint32;
        description "count";
      }

      leaf last-arg {
        type uint32;
        description "last arg";
      }
    }  // grouping L2VPN-STAT-ITEM

    grouping L2VPN-EVPN-ES-NH-BUFFER {
      description
        "L2VPN EVPN Ethernet Segment (ES) nexthops
       information";
      leaf next-hop {
        type inet:ipv6-address;
        description
          "Next-hop IP address (v6 format)";
      }

      leaf df-dont-preempt {
        type boolean;
        description "DF Dont Preemption";
      }

      leaf df-type {
        type uint8;
        description
          "DF Election Mode Configured";
      }

      leaf df-pref {
        type uint16;
        description
          "DF Election Preference Set";
      }

      leaf df-ntp-enabled {
        type boolean;
        description
          "NTP based DF Election Synchronization";
      }

      leaf ntp-sct-microseconds {
        type uint64;
        units "microsecond";
        description
          "NTP based SCT: represented in microseconds
         relative to Unix epoch: 1st Jan 1970";
      }
    }  // grouping L2VPN-EVPN-ES-NH-BUFFER

    grouping L2VPN-EVPN-ES {
      description
        "EVPN Ethernet Segment (ES) database information";
      container msti-flush-count {
        description
          "Statistics for Host-mobility driven flush
         operations";
        uses L2VPN-STAT-ITEM;
      }  // container msti-flush-count

      leaf esi-type {
        type L2vpn-evpn-esi;
        description "ESI Type";
      }

      leaf esi-system-identifier {
        type string;
        description "ESI System Identifier";
      }

      leaf esi-port-key {
        type uint32;
        description "ESI Port Key";
      }

      leaf esi-system-priority {
        type uint32;
        description "ESI System Priority";
      }

      leaf ethernet-segment-name {
        type string;
        description "Ethernet Segment Name";
      }

      leaf ethernet-segment-state {
        type L2vpn-evpn-es-state;
        description
          "State of the ethernet segment";
      }

      leaf in-staggered-bringup {
        type boolean;
        description
          "Is this ES in the staggered bring-up queue?";
      }

      leaf if-handle {
        type xr:Interface-name;
        description "Main port ifhandle";
      }

      leaf main-port-role {
        type L2vpn-rg-role;
        description
          "Main port redundancy group role";
      }

      leaf main-port-mac {
        type yang:mac-address;
        description "Main Port MAC Address";
      }

      leaf num-up-p-ws {
        type uint32;
        description
          "Number of PWs in Up state";
      }

      leaf route-target {
        type yang:mac-address;
        description "ES-Import Route Target";
      }

      leaf rt-origin {
        type L2vpn-evpn-rt-origin;
        description
          "Origin of operational ES-Import RT";
      }

      leaf es-bgp-gates {
        type string;
        description "ES BGP Gates";
      }

      leaf es-l2fib-gates {
        type string;
        description "ES L2FIB Gates";
      }

      leaf mac-flushing-mode-config {
        type L2vpn-evpn-mf-mode;
        description
          "Configured MAC Flushing mode";
      }

      leaf load-balance-mode-config {
        type L2vpn-evpn-lb-mode;
        description
          "Configured load balancing mode";
      }

      leaf load-balance-mode-is-default {
        type boolean;
        description
          "Load balancing mode is default";
      }

      leaf load-balance-mode-oper {
        type L2vpn-evpn-lb-mode;
        description
          "Operational load balancing mode";
      }

      leaf force-single-home {
        type boolean;
        description
          "Ethernet-Segment forced to single home";
      }

      leaf convergence-mac-mobility {
        type boolean;
        description
          "Fast convergence mode based on MAC-mobility.";
      }

      leaf convergence-reroute {
        type boolean;
        description
          "Fast convergence mode based on reroute to backup
         peer.";
      }

      leaf convergence-nh-tracking {
        type boolean;
        description
          "Fast DF-Election based on tracking peer BGP
         Nexthop reachability";
      }

      leaf source-mac-oper {
        type yang:mac-address;
        description
          "Operational Source MAC address";
      }

      leaf source-mac-origin {
        type L2vpn-evpn-smac-src;
        description
          "Origin of operational source MAC address";
      }

      leaf peering-timer {
        type uint32;
        units "second";
        description
          "Configured timer for triggering DF election
         (seconds)";
      }

      leaf peering-timer-left {
        type uint32;
        units "millisecond";
        description
          "Milliseconds left on DF election timer";
      }

      leaf recovery-timer {
        type uint32;
        units "second";
        description
          "Configured timer for (STP) recovery (seconds)";
      }

      leaf recovery-timer-left {
        type uint32;
        units "millisecond";
        description
          "Milliseconds left on (STP) recovery timer";
      }

      leaf carving-timer {
        type uint32;
        units "second";
        description
          "Configured timer for delaying DF election
         (seconds)";
      }

      leaf carving-timer-left {
        type uint32;
        units "millisecond";
        description
          "Milliseconds left on carving timer";
      }

      leaf hrw-reset-timer {
        type uint32;
        units "second";
        description
          "Configured timer for HRW reset (seconds)";
      }

      leaf hrw-reset-timer-left {
        type uint32;
        units "millisecond";
        description
          "Milliseconds left on HRW reset timer";
      }

      leaf service-carving-mode {
        type L2vpn-evpn-sc-mode;
        description "Service carving mode";
      }

      leaf service-carving-synchronization-mode {
        type L2vpn-evpn-sc-synchronization-mode;
        description
          "Service carving synchronization mode";
      }

      leaf service-carving-mcast-mode {
        type L2vpn-evpn-sc-mcast-mode;
        description
          "Service carving multicast mode";
      }

      leaf primary-services-input {
        type string;
        description
          "Input string of Primary services ESI/I-SIDs";
      }

      leaf secondary-services-input {
        type string;
        description
          "Input string of Secondary services ESI/I-SIDs";
      }

      leaf preferential-df-configured-weight {
        type uint16;
        description
          "Configured Weight for Preferential DF Election";
      }

      leaf preferential-df-operational-weight {
        type uint16;
        description
          "Operational Weight for Preferential DF Election";
      }

      leaf access-driven-df-election {
        type boolean;
        description
          "Access Driven DF Election is active";
      }

      leaf forwarder-ports {
        type uint32;
        description
          "Count of Forwarders (AC, AC PW, VFI PW)";
      }

      leaf permanent-forwarder-ports {
        type uint32;
        description
          "Count of Forwarders with permanent service";
      }

      leaf elected-forwarder-ports {
        type uint32;
        description
          "Count of Forwarders with elected service";
      }

      leaf not-elected-forwarder-ports {
        type uint32;
        description
          "Count of Forwarders with not elected service";
      }

      leaf not-config-forwarder-ports {
        type uint32;
        description
          "Count of forwarders with missing config detected";
      }

      leaf mp-protected {
        type boolean;
        description
          "MP is protected and not under EVPN control";
      }

      leaf nve-anycast-vtep {
        type boolean;
        description
          "Anycast VTEP mode on NVE main-interface";
      }

      leaf nve-ingress-replication {
        type boolean;
        description
          "Ingress-Replication is configured on NVE
         main-interface";
      }

      leaf msti-flush-debounce {
        type uint32;
        description
          "Value of scale-dependant debouncing";
      }

      leaf tracked-bgp-nexthop {
        type inet:ipv6-address;
        description
          "Reachability-tracked BGP Nexthop";
      }

      leaf local-split-horizon-group-label-valid {
        type boolean;
        description
          "Local split horizon group label is valid";
      }

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

      leaf access-signal-mode {
        type L2vpn-evpn-es-access-signal-mode;
        description
          "Operational access signal mode";
      }

      list ethernet-segment-identifier {
        description "Ethernet Segment id";
        leaf entry {
          type uint8;
          description "Ethernet Segment id";
        }
      }  // list ethernet-segment-identifier

      list primary-service {
        description
          "List of Primary services ESI/I-SIDs";
        leaf entry {
          type uint32;
          description
            "List of Primary services ESI/I-SIDs";
        }
      }  // list primary-service

      list secondary-service {
        description
          "List of Secondary services ESI/I-SIDs";
        leaf entry {
          type uint32;
          description
            "List of Secondary services ESI/I-SIDs";
        }
      }  // list secondary-service

      list service-carving-i-sidelected-result {
        description
          "Elected ISID service carving results";
        leaf entry {
          type uint32;
          description
            "Elected ISID service carving results";
        }
      }  // list service-carving-i-sidelected-result

      list service-carving-isid-not-elected-result {
        description
          "Not elected ISID service carving results";
        leaf entry {
          type uint32;
          description
            "Not elected ISID service carving results";
        }
      }  // list service-carving-isid-not-elected-result

      list service-carving-evi-elected-result {
        description
          "Elected EVI service carving results";
        leaf entry {
          type uint32;
          description
            "Elected EVI service carving results";
        }
      }  // list service-carving-evi-elected-result

      list service-carving-evi-not-elected-result {
        description
          "Not elected EVI service carving results";
        leaf entry {
          type uint32;
          description
            "Not elected EVI service carving results";
        }
      }  // list service-carving-evi-not-elected-result

      list service-carving-vni-elected-result {
        description
          "Elected VNI service carving results";
        leaf entry {
          type uint32;
          description
            "Elected VNI service carving results";
        }
      }  // list service-carving-vni-elected-result

      list service-carving-vni-not-elected-result {
        description
          "Not elected VNI service carving results";
        leaf entry {
          type uint32;
          description
            "Not elected VNI service carving results";
        }
      }  // list service-carving-vni-not-elected-result

      list next-hop {
        description
          "List of nexthop IPv6 addresses";
        uses L2VPN-EVPN-ES-NH-BUFFER;
      }  // list next-hop

      list service-carving-evpn-vpws-primary-result {
        description
          "EVPN VPWS service carving primary results";
        uses L2VPN-EVPN-EAD-SERVICE-INFO;
      }  // list service-carving-evpn-vpws-primary-result

      list service-carving-evpn-vpws-backup-result {
        description
          "EVPN VPWS service carving backup results";
        uses L2VPN-EVPN-EAD-SERVICE-INFO;
      }  // list service-carving-evpn-vpws-backup-result

      list service-carving-evpn-vpws-ndf-result {
        description
          "EVPN VPWS service carving non-DF results";
        uses L2VPN-EVPN-EAD-SERVICE-INFO;
      }  // list service-carving-evpn-vpws-ndf-result

      list remote-split-horizon-group-label {
        description
          "Remote split horizon group labels";
        uses L2VPN-EVPN-REMOTE-SHG-INFO;
      }  // list remote-split-horizon-group-label
    }  // grouping L2VPN-EVPN-ES

    grouping EVPN-SRV6-LOCATOR-INFO {
      description
        "EVPN SRv6 Locator information";
      leaf locator-name {
        type string;
        description "SRv6 Locator name";
      }

      leaf locator-prefix {
        type inet:ipv6-address;
        description "SRv6 Locator prefix";
      }

      leaf locator-length {
        type uint8;
        description "SRv6 Locator length";
      }

      leaf oor-state {
        type boolean;
        description "Out of Resources state";
      }

      leaf in-use {
        type boolean;
        description "In use by services";
      }

      leaf service-count {
        type uint32;
        description
          "Number of services using this locator implicitly
         and explicitly";
      }

      leaf sid-count {
        type uint32;
        description
          "Number of SIDs allocated by services for this
         locator";
      }

      leaf is-default {
        type boolean;
        description
          "Configured default locator";
      }

      list evi {
        description
          "List of EVIs with this locator explicitly
         
         configured";
        leaf entry {
          type uint32;
          description
            "List of EVIs with this locator explicitly
           
           configured";
        }
      }  // list evi

      list pw {
        description
          "List of VPWS services with this locator
         explicitly configured";
        uses EVPN-SRV6-VPWS-KEY;
      }  // list pw
    }  // grouping EVPN-SRV6-LOCATOR-INFO

    grouping EVPN-SRV6-VPWS-KEY {
      description
        "EVPN SRv6 VPWS service key";
      leaf evi {
        type uint32;
        description
          "EVI for the VPWS service";
      }

      leaf acid {
        type uint32;
        description
          "Attachment circuit ID for the VPWS service";
      }
    }  // grouping EVPN-SRV6-VPWS-KEY

    grouping L2VPN-EVPN-SRV6 {
      description "EVPN SRv6 info object";
      leaf enabled {
        type boolean;
        description "SRv6 Enabled";
      }

      leaf configured-default-locator {
        type string;
        description
          "Configured default SRv6 locator";
      }

      list unknown-locator-evi {
        description
          "List of EVIs with unknown locator names
         
         configured";
        leaf entry {
          type uint32;
          description
            "List of EVIs with unknown locator names
           
           configured";
        }
      }  // list unknown-locator-evi

      list unknown-locator-vpws {
        description
          "List of VPWS services with unknown locator names
         configured";
        uses EVPN-SRV6-VPWS-KEY;
      }  // list unknown-locator-vpws

      list locator {
        description
          "List of locators from L3RIB";
        uses EVPN-SRV6-LOCATOR-INFO;
      }  // list locator
    }  // grouping L2VPN-EVPN-SRV6

    grouping L2VPN-EVPN-LABEL {
      description
        "EVPN Internal Label database information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

      leaf esi {
        type yang:hex-string;
        description "Ethernet Segment id";
      }

      leaf tag {
        type uint32;
        description "Label Tag";
      }

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

      leaf alternate-internal-label {
        type uint32;
        description
          "Alternate MPLS Internal Label";
      }

      leaf internal-id {
        type uint32;
        description "SRv6 Internal ID";
      }

      leaf resolved {
        type boolean;
        description
          "Internal Label has resolved per-ES EAD and
         per-EVI EAD or MAC routes";
      }

      leaf unresolved-reason {
        type Evpn-bag-label-unresolved-reason;
        description
          "Optional reason why the label entry has not been
         resolved";
      }

      leaf preferred-nh-mode {
        type Evpn-pref-ecmp-nh-mode;
        description
          "Preferred ECMP Nexthop Mode";
      }

      leaf redundancy-single-active {
        type boolean;
        description
          "Single-active redundancy configured at remote ES";
      }

      leaf redundancy-single-flow-active {
        type boolean;
        description
          "Single-flow-active redundancy at remote ES
         (MST-AG)";
      }

      list mac-path-buffer {
        description "MAC Path list buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list mac-path-buffer

      list ead-path-buffer {
        description
          "EAD/ES Path list buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list ead-path-buffer

      list evi-path-buffer {
        description
          "EAD/EVI Path list buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list evi-path-buffer

      list union-path-buffer {
        description "Union Path list buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list union-path-buffer

      list summary-path-buffer {
        description
          "Summary Path list buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list summary-path-buffer

      list alternate-summary-path-buffer {
        description
          "Alternate Summary Path list buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list alternate-summary-path-buffer
    }  // grouping L2VPN-EVPN-LABEL

    grouping L2VPN-EVPN-TEP-INFO {
      description "L2VPN EVPN TEP INFO";
      leaf ethernet-vpn-id {
        type uint32;
        description "Ethernet VPN id";
      }

      leaf encapsulation {
        type uint8;
        description
          "EVPN Tunnel encapsulation";
      }

      leaf ip {
        type inet:ipv6-address;
        description "IP address (v6 format)";
      }
    }  // grouping L2VPN-EVPN-TEP-INFO

    grouping L2VPN-EVPN-TEP {
      description
        "EVPN Tunnel Endpoint database information";
      container local-info {
        description "Local TEP Information";
        uses L2VPN-EVPN-TEP-INFO;
      }  // container local-info

      container remote-info {
        description "Remote TEP Information";
        uses L2VPN-EVPN-TEP-INFO;
      }  // container remote-info

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

      leaf type {
        type uint8;
        description
          "EVPN Tunnel Endpoint Type";
      }

      leaf use-count {
        type uint32;
        description "in-use counter";
      }

      leaf vrf-name {
        type string;
        description "VRF Name";
      }

      leaf vrf-table-id {
        type uint32;
        description "VRF Table Id in RIB";
      }

      leaf udp-port {
        type uint16;
        description "UDP port";
      }
    }  // grouping L2VPN-EVPN-TEP

    grouping L2VPN-EVPN-TEP-NOTIFICATION-ENTRY {
      description
        "EVPN Tunnel Endpoint notification entry
       information";
      leaf entry-name {
        type string;
        description "Entry Name";
      }
    }  // grouping L2VPN-EVPN-TEP-NOTIFICATION-ENTRY

    grouping L2VPN-EVPN-MAC {
      description
        "L2VPN EVPN MAC database information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

      leaf ethernet-tag-xr {
        type uint32;
        description "Ethernet Tag";
      }

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

      leaf ip-address-xr {
        type inet:ipv6-address;
        description "IP address (v6 format)";
      }

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

      leaf is-local-mac {
        type boolean;
        description
          "Indication of MAC being locally generated";
      }

      leaf is-proxy-entry {
        type boolean;
        description "Proxy entry";
      }

      leaf is-remote-mac {
        type boolean;
        description
          "Indication of MAC being remotely generated";
      }

      leaf soo-nexthop {
        type inet:ipv6-address;
        description
          "SOO nexthop (v6 format)";
      }

      leaf ipnh-address {
        type inet:ipv6-address;
        description
          "IP nexthop address (v6 format)";
      }

      leaf esi-port-key {
        type uint16;
        description "ESI port key";
      }

      leaf local-encap-type {
        type uint8;
        description
          "Encap type of local MAC";
      }

      leaf remote-encap-type {
        type uint8;
        description
          "Encap type of remote MAC";
      }

      leaf learned-bridge-port-name {
        type string;
        description
          "Port the MAC was learned on";
      }

      leaf local-seq-id {
        type uint32;
        description "local seq id";
      }

      leaf remote-seq-id {
        type uint32;
        description "remote seq id";
      }

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

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

      leaf mac-flush-requested {
        type uint16;
        description
          "Number of flushes requested ";
      }

      leaf mac-flush-received {
        type uint16;
        description
          "Number of flushes received ";
      }

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

      leaf resolved {
        type boolean;
        description
          "Internal Label has resolved per-ES EAD and
         per-EVI EAD or MAC routes";
      }

      leaf local-is-static {
        type boolean;
        description
          "Indication if Local MAC is statically configured";
      }

      leaf remote-is-static {
        type boolean;
        description
          "Indication if Remote MAC is statically
         configured";
      }

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

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

      leaf remote-etree-rt-leaf {
        type boolean;
        description
          "Remote MAC matching E-Tree Route-Target Leaf";
      }

      leaf local-attachment-circuit-id {
        type uint32;
        description
          "Local Attachement Circuit ID used in
         ac-aware-vlan-bundling";
      }

      leaf remote-attachment-circuit-id {
        type uint32;
        description
          "Remote Attachement Circuit ID used in
         ac-aware-vlan-bundling";
      }

      list local-ethernet-segment-identifier {
        description
          "Local Ethernet Segment id";
        leaf entry {
          type uint8;
          description
            "Local Ethernet Segment id";
        }
      }  // list local-ethernet-segment-identifier

      list remote-ethernet-segment-identifier {
        description
          "Remote Ethernet Segment id";
        leaf entry {
          type uint8;
          description
            "Remote Ethernet Segment id";
        }
      }  // list remote-ethernet-segment-identifier

      list path-buffer {
        description "Path List Buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list path-buffer
    }  // grouping L2VPN-EVPN-MAC

    grouping L2VPN-EVPN-EVI-BGP-RT {
      description
        "EVPN Instance Route Target information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

      container route-target {
        description "Route Target";
        uses L2VPN-RT;
      }  // container route-target

      leaf route-target-role {
        type L2vpn-ad-rt-role;
        description "RT Role";
      }

      leaf route-target-stitching {
        type boolean;
        description "RT Stitching";
      }
    }  // grouping L2VPN-EVPN-EVI-BGP-RT

    grouping L2VPN-EVPN-IMCAST {
      description
        "L2VPN EVPN Inclusive Multicast database
       information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

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

      leaf ethernet-tag-xr {
        type uint32;
        description "Ethernet Tag";
      }

      leaf originating-ip-xr {
        type inet:ipv6-address;
        description "Originating IP";
      }

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

      leaf pmsi-tunnel-type {
        type uint32;
        description "PMSI Tunnel Type";
      }

      leaf next-hop {
        type inet:ipv6-address;
        description "IP of nexthop";
      }

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

      leaf is-local-entry {
        type boolean;
        description "Local entry";
      }

      leaf is-proxy-entry {
        type boolean;
        description "Proxy entry";
      }

      leaf etree-leaf {
        type boolean;
        description "E-Tree Leaf Indication";
      }
    }  // grouping L2VPN-EVPN-IMCAST

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    grouping L2VPN-EVPN-EAD {
      description
        "L2VPN EVPN EAD database information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

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

      leaf ethernet-tag-xr {
        type uint32;
        description "Ethernet Tag";
      }

      leaf local-next-hop {
        type inet:ipv6-address;
        description "Local nexthop IP";
      }

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

      leaf is-local-ead {
        type boolean;
        description
          "Indication of EthernetAutoDiscovery Route is
         local";
      }

      leaf redundancy-single-active {
        type boolean;
        description
          "Single-active redundancy configured at remote
         EAD";
      }

      leaf redundancy-single-flow-active {
        type boolean;
        description
          "Single-flow-active redundancy configured at
         remote EAD";
      }

      list ethernet-segment-identifier {
        description "Ethernet Segment id";
        leaf entry {
          type uint8;
          description "Ethernet Segment id";
        }
      }  // list ethernet-segment-identifier

      list local-sid-array {
        description "Associated local SIDs";
        uses L2VPN-EVPN-SRV6-SID-INFO;
      }  // list local-sid-array

      list path-buffer {
        description "Path List Buffer";
        uses L2VPN-LABEL-PATH-BUFFER;
      }  // list path-buffer
    }  // grouping L2VPN-EVPN-EAD

    grouping L2VPN-EVPN-NEIGHBOR {
      description
        "L2VPN EVPN Neighbor database information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

      leaf neighbor {
        type inet:ipv6-address;
        description "Neighbor IP";
      }

      list leaf-evis {
        description "Leaf EVIs";
        leaf entry {
          type uint32;
          description "Leaf EVIs";
        }
      }  // list leaf-evis
    }  // grouping L2VPN-EVPN-NEIGHBOR

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    grouping L2VPN-RD-AUTO {
      description "L2VPN RD AUTO";
      leaf router-id {
        type inet:ipv4-address;
        description "BGP Router ID";
      }

      leaf auto-index {
        type uint16;
        description "Auto-generated Index";
      }
    }  // grouping L2VPN-RD-AUTO

    grouping L2VPN-RD {
      description "L2VPN RD";
      container auto {
        when "../rd = 'l2vpn-ad-rd-auto'" {
          description
            "../RD = 'L2VPN_AD_RD_AUTO'";
        }
        description "auto";
        uses L2VPN-RD-AUTO;
      }  // container auto

      container two-byte-as {
        when "../rd = 'l2vpn-ad-rd-as'" {
          description
            "../RD = 'L2VPN_AD_RD_AS'";
        }
        description "two byte as";
        uses L2VPN-RD-2BYTE-AS;
      }  // container two-byte-as

      container four-byte-as {
        when
          "../rd = 'l2vpn-ad-rd-4byte-as'" {
          description
            "../RD = 'L2VPN_AD_RD_4BYTE_AS'";
        }
        description "four byte as";
        uses L2VPN-RD-4BYTE-AS;
      }  // container four-byte-as

      container v4-addr {
        when "../rd = 'l2vpn-ad-rd-v4-addr'" {
          description
            "../RD = 'L2VPN_AD_RD_V4ADDR'";
        }
        description "v4 addr";
        uses L2VPN-RD-V4ADDR;
      }  // container v4-addr

      leaf rd {
        type L2vpn-ad-rd;
        description "RD";
      }
    }  // grouping L2VPN-RD

    grouping L2VPN-EVPN-FLOW-LABEL {
      description "L2VPN EVPN FLOW LABEL";
      leaf static-flow-label {
        type boolean;
        description "Static flow label";
      }

      leaf global-flow-label {
        type boolean;
        description
          "Globally configured flow label";
      }
    }  // grouping L2VPN-EVPN-FLOW-LABEL

    grouping L2VPN-EVPN-EVI-DETAIL {
      description
        "EVPN E-VPN ID database detail information";
      container evpn-instance {
        description
          "EVPN Instance summary information";
        uses L2VPN-EVPN-EVI-SUMMARY;
      }  // container evpn-instance

      container flow-label {
        description "Flow Label Information";
        uses L2VPN-EVPN-FLOW-LABEL;
      }  // container flow-label

      container rd-auto {
        description
          "Automatic Route Distingtuisher";
        uses L2VPN-RD;
      }  // container rd-auto

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

      container rt-auto {
        description "Automatic Route Target";
        uses L2VPN-RT;
      }  // container rt-auto

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

      leaf encapsulation-xr {
        type uint8;
        description
          "EVPN Instance encapsulation";
      }

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

      leaf type {
        type L2vpn-evpn;
        description "Service Type";
      }

      leaf description {
        type string;
        description "EVI description";
      }

      leaf unicast-label {
        type uint32;
        description "Unicast Label";
      }

      leaf multicast-label {
        type uint32;
        description "Multicast Label";
      }

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

      leaf cw-disable {
        type boolean;
        description "Control-Word Disable";
      }

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

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

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

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

      leaf import-route-policy {
        type string;
        description "Import Route Policy";
      }

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

      leaf rt-import-block-set {
        type boolean;
        description "Is Import RT None set";
      }

      leaf rt-export-block-set {
        type boolean;
        description "Is Export RT None set";
      }

      leaf advertise-mac {
        type boolean;
        description
          "Advertise MAC-only routes on this EVI";
      }

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

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

      leaf advertise-bvi-mac {
        type boolean;
        description
          "Advertise BVI MACs routes on this EVI";
      }

      leaf aliasing-disabled {
        type boolean;
        description
          "Route Aliasing is disabled";
      }

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

      leaf reoriginate-disabled {
        type boolean;
        description
          "Route Re-origination is disabled";
      }

      leaf stitching {
        type boolean;
        description
          "EVPN Instance is Regular/Stitching side";
      }

      leaf multicast-source-connected {
        type boolean;
        description
          "EVI is connected to multicast source";
      }

      leaf bgp-implicit-import-disabled {
        type boolean;
        description
          "BGP implicit import is disabled";
      }

      leaf vrf-name {
        type string;
        description "L3 VRF name from BVI";
      }

      leaf preferred-nh-mode {
        type Evpn-pref-ecmp-nh-mode;
        description "Preferred Nexthop Mode";
      }

      leaf srv6-locator-name {
        type string;
        description "SRv6 Locator Name";
      }
    }  // grouping L2VPN-EVPN-EVI-DETAIL

    grouping L2VPN-EVPN-SUMMARY {
      description "EVPN Information Summary";
      leaf router-id {
        type inet:ipv6-address;
        description "EVPN Router ID";
      }

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

      leaf ev-is {
        type uint32;
        description
          "Number of EVI DB Entries";
      }

      leaf tunnel-endpoints {
        type uint32;
        description
          "Number of Tunnel Endpoint DB Entries";
      }

      leaf local-mac-routes {
        type uint32;
        description
          "Number of Local MAC Routes";
      }

      leaf local-ipv4-mac-routes {
        type uint32;
        description
          "Number of Local IPv4 MAC-IP Routes";
      }

      leaf local-ipv6-mac-routes {
        type uint32;
        description
          "Number of Local IPv6 MAC-IP Routes";
      }

      leaf es-global-mac-routes {
        type uint32;
        description
          "Number of ES:Global MAC Routes";
      }

      leaf remote-mac-routes {
        type uint32;
        description
          "Number of Remote MAC Routes";
      }

      leaf remote-sync-mac-routes {
        type uint32;
        description
          "Number of Remote SYNC MAC Routes";
      }

      leaf remote-ipv4-mac-routes {
        type uint32;
        description
          "Number of Remote IPv4 MAC-IP Routes";
      }

      leaf remote-ipv6-mac-routes {
        type uint32;
        description
          "Number of Remote IPv6 MAC-IP Routes";
      }

      leaf local-imcast-routes {
        type uint32;
        description
          "Number of Local IMCAST Routes";
      }

      leaf remote-imcast-routes {
        type uint32;
        description
          "Number of Remote IMCAST Routes";
      }

      leaf labels {
        type uint32;
        description
          "Number of Internal Labels";
      }

      leaf sh-internal-ids {
        type uint32;
        description
          "Number of single-homed Internal IDs";
      }

      leaf mh-internal-ids {
        type uint32;
        description
          "Number of multi-homed Internal IDs";
      }

      leaf es-entries {
        type uint32;
        description
          "Number of ES Entries in DB";
      }

      leaf neighbor-entries {
        type uint32;
        description
          "Number of neighbor Entries in DB";
      }

      leaf local-ead-routes {
        type uint32;
        description
          "Number of Local EAD Entries in DB";
      }

      leaf remote-ead-routes {
        type uint32;
        description
          "Number of Remote EAD Entries in DB";
      }

      leaf global-source-mac {
        type yang:mac-address;
        description
          "Global Source MAC Address";
      }

      leaf peering-time {
        type uint32;
        units "second";
        description
          "EVPN ES Peering Time (seconds)";
      }

      leaf recovery-time {
        type uint32;
        units "second";
        description
          "EVPN ES Recovery Time (seconds)";
      }

      leaf carving-time {
        type uint32;
        units "second";
        description
          "EVPN ES Carving Time (seconds)";
      }

      leaf cost-out-configured {
        type boolean;
        description
          "EVPN node cost out via manual configuration";
      }

      leaf bundle-convergence-in-progress {
        type boolean;
        description
          "Bundle convergence in progress";
      }

      leaf node-costed-out {
        type boolean;
        description
          "EVPN Services costed out on node and holding
         Bundle interfaces down";
      }

      leaf startup-cost-in-time {
        type uint32;
        units "second";
        description
          "EVPN Node startup cost-in Time (seconds)";
      }

      leaf startup-cost-in-time-left {
        type uint32;
        units "millisecond";
        description
          "Milliseconds left on EVPN Node startup cost-in";
      }

      leaf mac-postpone-timer {
        type uint32;
        units "second";
        description
          "Configured timer for postponing MAC withdraws
         (seconds)";
      }

      leaf mac-postpone-timer-left {
        type uint32;
        units "millisecond";
        description
          "Milliseconds left on MAC withdraw postpone timer";
      }

      leaf l2rib-throttle {
        type boolean;
        description
          "Send to L2RIB Throttled";
      }

      leaf logging-df-election-enabled {
        type boolean;
        description
          "Logging EVPN Designated Forwarder changes
         enabled";
      }
    }  // grouping L2VPN-EVPN-SUMMARY

    grouping L2VPN-EVPN-EVI-SUMMARY {
      description
        "EVPN Instance summary information";
      leaf ethernet-vpn-id {
        type uint32;
        description "Ethernet VPN id";
      }

      leaf encapsulation-xr {
        type uint8;
        description
          "EVPN Instance transport encapsulation";
      }

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

      leaf type {
        type L2vpn-evpn;
        description "Service Type";
      }
    }  // grouping L2VPN-EVPN-EVI-SUMMARY

    grouping L2VPN-EVPN-IGMP-SUBIF-INFO {
      description
        "L2VPN EVPN IGMP SUBIF INFO";
      leaf vrf-id {
        type uint32;
        description "VRF id";
      }
    }  // grouping L2VPN-EVPN-IGMP-SUBIF-INFO

    grouping L2VPN-EVPN-IGMP-FWD-INFO {
      description "L2VPN EVPN IGMP FWD INFO";
      leaf bd-id {
        type uint32;
        description "BD id";
      }
    }  // grouping L2VPN-EVPN-IGMP-FWD-INFO

    grouping EVPN-IGMP-CHILD-INFO {
      description "EVPN IGMP CHILD INFO";
      container fwd-info {
        when "../child-type = 'l2-fwd'" {
          description
            "../ChildType = 'L2_FWD'";
        }
        description "fwd info";
        uses L2VPN-EVPN-IGMP-FWD-INFO;
      }  // container fwd-info

      container subif-info {
        when "../child-type = 'l3-sub-if'" {
          description
            "../ChildType = 'L3_SUBIF'";
        }
        description "subif info";
        uses L2VPN-EVPN-IGMP-SUBIF-INFO;
      }  // container subif-info

      leaf child-type {
        type Evpn-child;
        description "ChildType";
      }
    }  // grouping EVPN-IGMP-CHILD-INFO

    grouping L2VPN-EVPN-IGMP-LOCAL-INFO {
      description
        "L2VPN EVPN IGMP LOCAL INFO";
      leaf if-name {
        type string {
          length "0..65";
        }
        description
          "Interface name internal format";
      }
    }  // grouping L2VPN-EVPN-IGMP-LOCAL-INFO

    grouping EVPN-IGMP-SRC-INFO {
      description "EVPN IGMP SRC INFO";
      container local-info {
        when "../type = 'local'" {
          description "../Type = 'Local'";
        }
        description "local info";
        uses L2VPN-EVPN-IGMP-LOCAL-INFO;
      }  // container local-info

      leaf type {
        type Evpn-igmp-source;
        description "Type";
      }

      leaf remote-info {
        when "../type = 'remote'" {
          description "../Type = 'Remote'";
        }
        type L2vpn-bag-in6-addr;
        description "remote info";
      }
    }  // grouping EVPN-IGMP-SRC-INFO

    grouping L2VPN-EVPN-IGMP {
      description
        "EVPN IGMP database information";
      container source-info {
        description "Source Info";
        uses EVPN-IGMP-SRC-INFO;
      }  // container source-info

      container child-info {
        description "Child Info";
        uses EVPN-IGMP-CHILD-INFO;
      }  // container child-info

      leaf evpn-client-type {
        type Evpn-client1;
        description "EVPN Client Type";
      }

      leaf ethernet-segment-name {
        type string;
        description "Ethernet Segment Name";
      }

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

      leaf route-type {
        type Evpn-igmp-msg;
        description "Route Type";
      }

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

      leaf group-addr {
        type inet:ipv6-address;
        description "Group IP Address";
      }

      leaf originating-ip-xr {
        type inet:ipv6-address;
        description
          "Originating IP Address (remotes)";
      }

      leaf ethernet-tag-id {
        type uint32;
        description "Ethernet Tag id";
      }

      leaf igmp-version {
        type Evpn-igmp-version;
        description "IGMP Version";
      }

      leaf igmp-group-type {
        type Evpn-igmp-grp;
        description "IGMP Group Type";
      }

      leaf max-response-time {
        type uint8;
        description "Max Response Time";
      }

      leaf resolved {
        type boolean;
        description "Resolved";
      }

      list ethernet-segment-identifier {
        description "Ethernet Segment id";
        leaf entry {
          type uint8;
          description "Ethernet Segment id";
        }
      }  // list ethernet-segment-identifier
    }  // grouping L2VPN-EVPN-IGMP

    grouping L2VPN-EVPN-CLIENT {
      description "EVPN Client Information";
      leaf client-type {
        type Evpn-client1;
        description "Client Type";
      }
    }  // grouping L2VPN-EVPN-CLIENT

    grouping L2VPN-EVPN-REMOTE-SHG-INFO {
      description
        "L2VPN EVPN remote split horizon group labels";
      leaf next-hop {
        type inet:ipv6-address;
        description
          "Next-hop IP address (v6 format)";
      }

      leaf label {
        type uint32;
        description
          "Split horizon label associated with next-hop
         address";
      }
    }  // grouping L2VPN-EVPN-REMOTE-SHG-INFO

    grouping L2VPN-EVPN-REMOTE-SHG {
      description "EVPN Remote SHG object";
      leaf ethernet-vpn-id {
        type uint32;
        description "Ethernet VPN id";
      }

      leaf encapsulation {
        type uint8;
        description
          "EVPN Instance transport encapsulation";
      }

      list ethernet-segment-identifier {
        description "Ethernet Segment id";
        leaf entry {
          type uint8;
          description "Ethernet Segment id";
        }
      }  // list ethernet-segment-identifier

      list remote-split-horizon-group-label {
        description
          "Remote split horizon group labels";
        uses L2VPN-EVPN-REMOTE-SHG-INFO;
      }  // list remote-split-horizon-group-label
    }  // grouping L2VPN-EVPN-REMOTE-SHG

    grouping EVPN-GRP-INTF-INFO {
      description
        "EVPN Group Interface Information";
      leaf interface-name {
        type string;
        description "Interface name";
      }

      leaf state {
        type Im-state-enum;
        description "Interface State";
      }
    }  // grouping EVPN-GRP-INTF-INFO

    grouping EVPN-GRP-INFO {
      description "EVPN Group Information";
      leaf group-id {
        type uint32;
        description "EVPN Group ID";
      }

      leaf state {
        type Evpn-grp;
        description "EVPN Group State";
      }

      list core-interface {
        description
          "EVPN Group Core Interface table";
        uses EVPN-GRP-INTF-INFO;
      }  // list core-interface

      list access-interface {
        description
          "EVPN Access Core Interface table";
        uses EVPN-GRP-INTF-INFO;
      }  // list access-interface
    }  // grouping EVPN-GRP-INFO
  }  // submodule Cisco-IOS-XR-evpn-oper-sub1