+---------------+
                          |   Customer    |
                          +-------+-------+
          Customer Service Model  |
              e.g., l2vpn-svc     |
                          +-------+-------+
                          |    Service    |
                          | Orchestration |
                          +-------+-------+
           Network Model          |
        l2vpn-ntw + l2vpn-es      |
                          +-------+-------+
                          |   Network     |
                          | Orchestration |
                          +-------+-------+
    Network Configuration Model   |
                      +-----------+-----------+
                      |                       |
             +--------+------+       +--------+------+
             |    Domain     |       |     Domain    |
             | Orchestration |       | Orchestration |
             +---+-----------+       +--------+------+
  Device         |        |                   |
  Configuration  |        |                   |
  Model          |        |                   |
            +----+----+   |                   |
            | Config  |   |                   |
            | Manager |   |                   |
            +----+----+   |                   |
                 |        |                   |
                 | NETCONF/CLI..................
                 |        |                   |
               +--------------------------------+
                \            Network           /  
                 \                           /
+----+  Bearer    +----+              +----+         +----+
|CE A+ ---------- +PE A+              +PE B+ ------- +CE B|
+----+ Connection +----+              +----+         +----+

        Site A                                 Site B

NETCONF:  Network Configuration Protocol
CLI:  Command-Line Interface            

               +----------------------------------+
               | Customer                         |
               | +-----------------------------+  |
               | |             CNC             |  |
               | +-----------------------------+  |
               +----+-----------------------+-----+
                    |                       |
                    | L2SM                  | L2SM
                    |                       |
          +---------+---------+   +---------+---------+
          | MDSC              |   |       MDSC        |
          | +---------------+ |   |     (parent)      |
          | |    Service    | |   +---------+---------+
          | | Orchestration | |             |
          | +-------+-------+ |             | L2NM
          |         |         |             |
          |         | L2NM    |   +---------+---------+
          |         |         |   |       MDSC        |
          | +-------+-------+ |   |      (child)      |
          | |    Network    | |   +---------+---------+
          | | Orchestration | |             |
          | +---------------+ |             |
          +---------+---------+             |
                    |                       |
                    | Network Configuration |
                    |                       |
       +------------+-------+     +---------+------------+
       | Domain             |     |           Domain     |
       | Controller         |     |           Controller |
       |       +---------+  |     |    +---------+       |
       |       |   PNC   |  |     |    |   PNC   |       |
       |       +---------+  |     |    +---------+       |
       +------------+-------+     +---------+------------+
                    |                       |
                    | Device Configuration  |
                    |                       |
               +----+---+              +----+---+
               | Device |              | Device |
               +--------+              +--------+        

module: ietf-ethernet-segment
  +--rw ethernet-segments
     +--rw ethernet-segment* [name]
        +--rw name                                 string
        +--rw esi-type?                            identityref
        +--rw (esi-choice)?
        |  +--:(directly-assigned)
        |  |  +--rw ethernet-segment-identifier?   yang:hex-string
        |  +--:(auto-assigned)
        |     +--rw esi-auto
        |        +--rw (auto-mode)?
        |        |  +--:(from-pool)
        |        |  |  +--rw esi-pool-name?                string
        |        |  +--:(full-auto)
        |        |     +--rw auto?                         empty
        |        +--ro auto-ethernet-segment-identifier?
        |                yang:hex-string
        +--rw esi-redundancy-mode?                 identityref
        +--rw df-election
        |  +--rw df-election-method?   identityref
        |  +--rw revertive?            boolean
        |  +--rw election-wait-time?   uint32
        +--rw split-horizon-filtering?             boolean
        +--rw pbb
        |  +--rw backbone-src-mac?   yang:mac-address
        +--rw member* [ne-id interface-id]
           +--rw ne-id           string
           +--rw interface-id    string

module: ietf-l2vpn-ntw
  +--rw l2vpn-ntw
     +--rw vpn-profiles
     |  ...
     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 ...
                 +--rw vpn-network-accesses
                    +--rw vpn-network-access* [id]
                       ...

  +--rw l2vpn-ntw
     +--rw vpn-profiles
     |  +--rw valid-provider-identifiers
     |     +--rw external-connectivity-identifier* [id]
     |     |       {external-connectivity}?
     |     |  +--rw id    string
     |     +--rw encryption-profile-identifier* [id]
     |     |  +--rw id    string
     |     +--rw qos-profile-identifier* [id]
     |     |  +--rw id    string
     |     +--rw bfd-profile-identifier* [id]
     |     |  +--rw id    string
     |     +--rw forwarding-profile-identifier* [id]
     |     |  +--rw id    string
     |     +--rw routing-profile-identifier* [id]
     |        +--rw id    string
     +--rw vpn-services
        ...

     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           +--rw vpn-id                        vpn-common:vpn-id
           +--rw vpn-name?                     string
           +--rw vpn-description?              string
           +--rw customer-name?                string
           +--rw parent-service-id?            vpn-common:vpn-id
           +--rw vpn-type?                     identityref
           +--rw vpn-service-topology?         identityref
           +--rw bgp-ad-enabled?               boolean
           +--rw signaling-type?               identityref
           +--rw global-parameters-profiles
           |  ...
           +--rw underlay-transport
           |  +--rw (type)?
           |     +--:(abstract)
           |     |  +--rw transport-instance-id?   string
           |     |  +--rw instance-type?           identityref
           |     +--:(protocol)
           |        +--rw protocol*                identityref
           +--rw status
           |  +--rw admin-status
           |  |  +--rw status?         identityref
           |  |  +--rw last-change?   yang:date-and-time
           |  +--ro oper-status
           |     +--ro status?         identityref
           |     +--ro last-change?   yang:date-and-time
           +--rw vpn-nodes
              ...

     ...
     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           ...
           +--rw global-parameters-profiles
           |  +--rw global-parameters-profile* [profile-id]
           |     +--rw profile-id                  string
           |     +--rw (rd-choice)?
           |     |  +--:(directly-assigned)
           |     |  |  +--rw rd?
           |     |  |          rt-types:route-distinguisher
           |     |  +--:(directly-assigned-suffix)
           |     |  |  +--rw rd-suffix?            uint16
           |     |  +--:(auto-assigned)
           |     |  |  +--rw rd-auto
           |     |  |     +--rw (auto-mode)?
           |     |  |     |  +--:(from-pool)
           |     |  |     |  |  +--rw rd-pool-name?   string
           |     |  |     |  +--:(full-auto)
           |     |  |     |     +--rw auto?           empty
           |     |  |     +--ro auto-assigned-rd?
           |     |  |             rt-types:route-distinguisher
           |     |  +--:(auto-assigned-suffix)
           |     |  |  +--rw rd-auto-suffix
           |     |  |     +--rw (auto-mode)?
           |     |  |     |  +--:(from-pool)
           |     |  |     |  |  +--rw rd-pool-name?        string
           |     |  |     |  +--:(full-auto)
           |     |  |     |     +--rw auto?                empty
           |     |  |     +--ro auto-assigned-rd-suffix?   uint16
           |     |  +--:(no-rd)
           |     |     +--rw no-rd?                empty
           |     +--rw vpn-target* [id]
           |     |  +--rw id                  uint8
           |     |  +--rw route-targets* [route-target]
           |     |  |  +--rw route-target    rt-types:route-target
           |     |  +--rw route-target-type
           |     |          rt-types:route-target-type
           |     +--rw vpn-policies
           |     |  +--rw import-policy?   string
           |     |  +--rw export-policy?   string
           |     +--rw local-autonomous-system?    inet:as-number
           |     +--rw svc-mtu?                    uint32
           |     +--rw ce-vlan-preservation?       boolean
           |     +--rw ce-vlan-cos-preservation?   boolean
           |     +--rw control-word-negotiation?   boolean
           |     +--rw mac-policies
           |     |  +--rw mac-addr-limit
           |     |  |  +--rw limit-number?    uint16
           |     |  |  +--rw time-interval?   uint32
           |     |  |  +--rw action?          identityref
           |     |  +--rw mac-loop-prevention
           |     |     +--rw window?            uint32
           |     |     +--rw frequency?         uint32
           |     |     +--rw retry-timer?       uint32
           |     |     +--rw protection-type?   identityref
           |     +--rw multicast {vpn-common:multicast}?
           |        +--rw enabled?                 boolean
           |        +--rw customer-tree-flavors
           |           +--rw tree-flavor*   identityref
                    ...

  +--rw l2vpn-ntw
     +--rw vpn-profiles
     |  ...
     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 +--rw vpn-node-id            vpn-common:vpn-id
                 +--rw description?           string
                 +--rw ne-id?                 string
                 +--rw role?                  identityref
                 +--rw router-id?             rt-types:router-id
                 +--rw active-global-parameters-profiles
                 |  +--rw global-parameters-profile* [profile-id]
                 |     +--rw profile-id                  leafref
                 |     +--rw local-autonomous-system?
                 |     |       inet:as-number
                 |     +--rw svc-mtu?                    uint32
                 |     +--rw ce-vlan-preservation?       boolean
                 |     +--rw ce-vlan-cos-preservation?   boolean
                 |     +--rw control-word-negotiation?   boolean
                 |     +--rw mac-policies
                 |     |  +--rw mac-addr-limit
                 |     |  |  +--rw limit-number?    uint16
                 |     |  |  +--rw time-interval?   uint32
                 |     |  |  +--rw action?          identityref
                 |     |  +--rw mac-loop-prevention
                 |     |     +--rw window?            uint32
                 |     |     +--rw frequency?         uint32
                 |     |     +--rw retry-timer?       uint32
                 |     |     +--rw protection-type?   identityref
                 |     +--rw multicast {vpn-common:multicast}?
                 |        +--rw enabled?                 boolean
                 |        +--rw customer-tree-flavors
                 |           +--rw tree-flavor*   identityref
                 +--rw status
                 |  ...
                 +--rw bgp-auto-discovery
                 |  ...
                 +--rw signaling-option
                 |  ...
                 +--rw vpn-network-accesses
                    ...

  +--rw l2vpn-ntw
     +--rw vpn-profiles
     |  ...
     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 ...
                 +--rw bgp-auto-discovery
                 |  +--rw (bgp-type)?
                 |  |  +--:(l2vpn-bgp)
                 |  |  |  +--rw vpn-id?
                 |  |  |          vpn-common:vpn-id
                 |  |  +--:(evpn-bgp)
                 |  |     +--rw evpn-type?           leafref
                 |  |     +--rw auto-rt-enable?      boolean
                 |  |     +--ro auto-route-target?
                 |  |             rt-types:route-target
                 |  +--rw (rd-choice)?
                 |  |  +--:(directly-assigned)
                 |  |  |  +--rw rd?
                 |  |  |          rt-types:route-distinguisher
                 |  |  +--:(directly-assigned-suffix)
                 |  |  |  +--rw rd-suffix?           uint16
                 |  |  +--:(auto-assigned)
                 |  |  |  +--rw rd-auto
                 |  |  |     +--rw (auto-mode)?
                 |  |  |     |  +--:(from-pool)
                 |  |  |     |  |  +--rw rd-pool-name?   string
                 |  |  |     |  +--:(full-auto)
                 |  |  |     |     +--rw auto?           empty
                 |  |  |     +--ro auto-assigned-rd?
                 |  |  |             rt-types:route-distinguisher
                 |  |  +--:(auto-assigned-suffix)
                 |  |  |  +--rw rd-auto-suffix
                 |  |  |     +--rw (auto-mode)?
                 |  |  |     |  +--:(from-pool)
                 |  |  |     |  |  +--rw rd-pool-name?        string
                 |  |  |     |  +--:(full-auto)
                 |  |  |     |     +--rw auto?                empty
                 |  |  |     +--ro auto-assigned-rd-suffix?   uint16
                 |  |  +--:(no-rd)
                 |  |     +--rw no-rd?               empty
                 |  +--rw vpn-target* [id]
                 |  |  +--rw id                   uint8
                 |  |  +--rw route-targets* [route-target]
                 |  |  |  +--rw route-target    rt-types:route-target
                 |  |  +--rw route-target-type
                 |  |          rt-types:route-target-type
                 |  +--rw vpn-policies
                 |     +--rw import-policy?   string
                 |     +--rw export-policy?   string
                 +--rw signaling-option
                 |  ...
                 +--rw vpn-network-accesses
                    ...

...
+--rw vpn-nodes
   +--rw vpn-node* [vpn-node-id]
   ...
   +--rw signaling-option
   |  +--rw advertise-mtu?        boolean
   |  +--rw mtu-allow-mismatch?   boolean
   |  +--rw signaling-type?       leafref
   |  +--rw (signaling-option)?
   |     +--:(bgp)
   |     |  ...
   |     +--:(ldp-or-l2tp)
   |        +--rw ldp-or-l2tp
   |           ...
   |           +--rw (ldp-or-l2tp)?
   |              +--:(ldp)
   |              |  ...
   |              +--:(l2tp)
   |                 ...

   ...
   |  +--rw (signaling-option)?
   |     ...
   |     +--:(bgp)
   |     |  +--rw (bgp-type)?
   |     |     +--:(l2vpn-bgp)
   |     |     |  +--rw ce-range?     uint16
   |     |     |  +--rw pw-encapsulation-type?
   |     |     |  |       identityref
   |     |     |  +--rw vpls-instance
   |     |     |     +--rw vpls-edge-id?         uint16
   |     |     |     +--rw vpls-edge-id-range?   uint16
   |     |     +--:(evpn-bgp)
   |     |        +--rw evpn-type?                leafref
   |     |        +--rw service-interface-type?
   |     |        |       identityref
   |     |        +--rw evpn-policies
   |     |           +--rw mac-learning-mode?
   |     |           |       identityref
   |     |           +--rw ingress-replication?
   |     |           |       boolean
   |     |           +--rw p2mp-replication?
   |     |           |       boolean
   |     |           +--rw arp-proxy {vpn-common:ipv4}?
   |     |           |  +--rw enable?           boolean
   |     |           |  +--rw arp-suppression?
   |     |           |  |       boolean
   |     |           |  +--rw ip-mobility-threshold?
   |     |           |  |       uint16
   |     |           |  +--rw duplicate-ip-detection-interval?
   |     |           |          uint16
   |     |           +--rw nd-proxy {vpn-common:ipv6}?
   |     |           |  +--rw enable?          boolean
   |     |           |  +--rw nd-suppression?
   |     |           |  |       boolean
   |     |           |  +--rw ip-mobility-threshold?
   |     |           |  |       uint16
   |     |           |  +--rw duplicate-ip-detection-interval?
   |     |           |          uint16
   |     |           +--rw underlay-multicast?
   |     |           |       boolean
   |     |           +--rw flood-unknown-unicast-suppression?
   |     |           |       boolean
   |     |           +--rw vpws-vlan-aware?        boolean
   |     |           +--rw bum-management
   |     |           |  +--rw discard-broadcast?
   |     |           |  |       boolean
   |     |           |  +--rw discard-unknown-multicast?
   |     |           |  |       boolean
   |     |           |  +--rw discard-unknown-unicast?
   |     |           |          boolean
   |     |           +--rw pbb
   |     |              +--rw backbone-src-mac?
   |     |                      yang:mac-address
   |     +--:(ldp-or-l2tp)
   |        ...

   ...
   |  +--rw (signaling-option)?
   |     ...
   |     +--:(bgp)
   |     |  ...
   |     +--:(ldp-or-l2tp)
   |        +--rw ldp-or-l2tp
   |           +--rw agi?
   |           |       rt-types:route-distinguisher
   |           +--rw saii?                      uint32
   |           +--rw remote-targets* [taii]
   |           |  +--rw taii         uint32
   |           |  +--rw peer-addr    inet:ip-address
   |           +--rw (ldp-or-l2tp)?
   |              +--:(ldp)
   |              |  +--rw t-ldp-pw-type?
   |              |  |       identityref
   |              |  +--rw pw-type?       identityref
   |              |  +--rw pw-description?      string
   |              |  +--rw mac-addr-withdraw?   boolean
   |              |  +--rw pw-peer-list*
   |              |  |       [peer-addr vc-id]
   |              |  |  +--rw peer-addr
   |              |  |  |       inet:ip-address
   |              |  |  +--rw vc-id   string
   |              |  |  +--rw pw-priority?   uint32
   |              |  +--rw qinq
   |              |     +--rw s-tag   dot1q-types:vlanid
   |              |     +--rw c-tag   dot1q-types:vlanid
   |              +--:(l2tp)
   |                 ...
   ...

   ...
   |  +--rw (signaling-option)?
   |     ...
   |     +--:(bgp)
   |     |  ...
   |     +--:(ldp-or-l2tp)
   |        +--rw ldp-or-l2tp
   |           +--rw agi?
   |           |       rt-types:route-distinguisher
   |           +--rw saii?                      uint32
   |           +--rw remote-targets* [taii]
   |           |  +--rw taii         uint32
   |           |  +--rw peer-addr    inet:ip-address
   |           +--rw (ldp-or-l2tp)?
   |              +--:(ldp)
   |              |  ...
   |              +--:(l2tp)
   |                 +--rw router-id?
   |                 |       rt-types:router-id
   |                 +--rw pseudowire-type?
   |                         identityref
   ...

           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 ...
                 +--rw vpn-network-accesses
                    +--rw vpn-network-access* [id]
                       +--rw id                     vpn-common:vpn-id
                       +--rw description?              string
                       +--rw interface-id?             string
                       +--rw active-vpn-node-profile?   leafref
                       +--rw status
                       |  ...
                       +--rw connection
                       |  ...
                       +--rw (signaling-option)?
                       |  +--:(bgp)
                       |     +--rw (bgp-type)?
                       |        +--:(l2vpn-bgp)
                       |        |  +--rw ce-id?             uint16
                       |        |  +--rw remote-ce-id?      uint16
                       |        |  +--rw vpls-instance
                       |        |     +--rw vpls-edge-id?   uint16
                       |        +--:(evpn-bgp)
                       |           +--rw df-preference?     uint16
                       |           +--rw vpws-service-instance
                       |              ...
                       +--rw group* [group-id]
                       |  +--rw group-id                       string
                       |  +--rw precedence?               identityref
                       |  +--rw ethernet-segment-identifier?
                       |                              l2vpn-es:es-ref
                       +--rw ethernet-service-oam
                       |  ...
                       +--rw service
                          ...

           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 ...
                 +--rw vpn-network-accesses
                    +--rw vpn-network-access* [id]
                       ...
                       +--rw connection
                       |  +--rw l2-termination-point?
                       |  |       string
                       |  +--rw local-bridge-reference?
                       |  |       string
                       |  +--rw bearer-reference?         string
                       |  |       {vpn-common:bearer-reference}?
                       |  +--rw encapsulation
                       |  |  +--rw encap-type?            identityref
                       |  |  +--rw dot1q
                       |  |  |  +--rw tag-type?           identityref
                       |  |  |  +--rw cvlan-id?
                       |  |  |  |       dot1q-types:vlanid
                       |  |  |  +--rw tag-operations
                       |  |  |     +--rw (op-choice)?
                       |  |  |     |  +--:(pop)
                       |  |  |     |  |  +--rw pop?         empty
                       |  |  |     |  +--:(push)
                       |  |  |     |  |  +--rw push?        empty
                       |  |  |     |  +--:(translate)
                       |  |  |     |     +--rw translate?   empty
                       |  |  |     +--rw tag-1?
                       |  |  |     |       dot1q-types:vlanid
                       |  |  |     +--rw tag-1-type?
                       |  |  |     |       dot1q-types:dot1q-tag-type
                       |  |  |     +--rw tag-2?
                       |  |  |     |       dot1q-types:vlanid
                       |  |  |     +--rw tag-2-type?
                       |  |  |             dot1q-types:dot1q-tag-type
                       |  |  +--rw priority-tagged
                       |  |  |  +--rw tag-type?   identityref
                       |  |  +--rw qinq
                       |  |     +--rw tag-type?         identityref
                       |  |     +--rw svlan-id
                       |  |     |       dot1q-types:vlanid
                       |  |     +--rw cvlan-id
                       |  |     |       dot1q-types:vlanid
                       |  |     +--rw tag-operations
                       |  |        +--rw (op-choice)?
                       |  |        |  +--:(pop)
                       |  |        |  |  +--rw pop?         uint8
                       |  |        |  +--:(push)
                       |  |        |  |  +--rw push?        empty
                       |  |        |  +--:(translate)
                       |  |        |     +--rw translate?   empty
                       |  |        +--rw tag-1?
                       |  |        |       dot1q-types:vlanid
                       |  |        +--rw tag-1-type?
                       |  |        |       dot1q-types:dot1q-tag-type
                       |  |        +--rw tag-2?
                       |  |        |       dot1q-types:vlanid
                       |  |        +--rw tag-2-type?
                       |  |                dot1q-types:dot1q-tag-type
                       |  +--rw lag-interface
                       |     |    {vpn-common:lag-interface}?
                       |     +--rw lag-interface-id?   string
                       |     +--rw lacp
                       |     |  +--rw lacp-state?         boolean
                       |     |  +--rw mode?               identityref
                       |     |  +--rw speed?              uint32
                       |     |  +--rw mini-link-num?      uint32
                       |     |  +--rw system-id?
                       |     |  |       yang:mac-address
                       |     |  +--rw admin-key?          uint16
                       |     |  +--rw system-priority?    uint16
                       |     |  +--rw member-link-list
                       |     |  |  +--rw member-link* [name]
                       |     |  |     +--rw name         string
                       |     |  |     +--rw speed?       uint32
                       |     |  |     +--rw mode?   identityref
                       |     |  |     +--rw link-mtu?    uint32
                       |     |  |     +--rw oam-802.3ah-link
                       |     |  |        |    {oam-3ah}?
                       |     |  |        +--rw enable?   boolean
                       |     |  +--rw flow-control?       boolean
                       |     |  +--rw lldp?               boolean
                       |     +--rw split-horizon
                       |        +--rw group-name?   string
                       ...

...
+--rw vpn-nodes
   +--rw vpn-node* [vpn-node-id]
      ...
      +--rw vpn-network-accesses
         +--rw vpn-network-access* [id]
            ...
            +--rw (signaling-option)?
            |  +--:(bgp)
            |     +--rw (bgp-type)?
            |        +--:(l2vpn-bgp)
            |        |  ...
            |        +--:(evpn-bgp)
            |           +--rw df-preference?     uint16
            |           +--rw vpws-service-instance
            |              +--rw (local-vsi-choice)?
            |              |  +--:(directly-assigned)
            |              |  |  +--rw local-vpws-service-instance?
            |              |  |          uint32
            |              |  +--:(auto-assigned)
            |              |     +--rw local-vsi-auto
            |              |        +--rw (auto-mode)?
            |              |        |  +--:(from-pool)
            |              |        |  |  +--rw vsi-pool-name?
            |              |        |  |          string
            |              |        |  +--:(full-auto)
            |              |        |     +--rw auto?      empty
            |              |        +--ro auto-local-vsi?  uint32
            |              +--rw (remote-vsi-choice)?
            |                 +--:(directly-assigned)
            |                 |  +--rw remote-vpws-service-instance?
            |                 |          uint32
            |                 +--:(auto-assigned)
            |                    +--rw remote-vsi-auto
            |                       +--rw (auto-mode)?
            |                       |  +--:(from-pool)
            |                       |  |  +--rw vsi-pool-name?
            |                       |  |          string
            |                       |  +--:(full-auto)
            |                       |     +--rw auto?       empty
            |                       +--ro auto-remote-vsi?  uint32
            ...

  +--rw l2vpn-ntw
     +--rw vpn-profiles
     |  ...
     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 ...
                 +--rw vpn-network-accesses
                    +--rw vpn-network-access* [id]
                       ...
                       +--rw ethernet-service-oam
                       |  +--rw md-name?        string
                       |  +--rw md-level?       uint8
                       |  +--rw cfm-802.1-ag
                       |  |  +--rw n2-uni-c* [maid]
                       |  |  |  +--rw maid                string
                       |  |  |  +--rw mep-id?             uint32
                       |  |  |  +--rw mep-level?          uint32
                       |  |  |  +--rw mep-up-down?
                       |  |  |  |                   enumeration
                       |  |  |  +--rw remote-mep-id?      uint32
                       |  |  |  +--rw cos-for-cfm-pdus?   uint32
                       |  |  |  +--rw ccm-interval?       uint32
                       |  |  |  +--rw ccm-holdtime?       uint32
                       |  |  |  +--rw ccm-p-bits-pri?
                       |  |  |          ccm-priority-type
                       |  |  +--rw n2-uni-n* [maid]
                       |  |     +--rw maid                string
                       |  |     +--rw mep-id?             uint32
                       |  |     +--rw mep-level?          uint32
                       |  |     +--rw mep-up-down?
                       |  |     |                    enumeration
                       |  |     +--rw remote-mep-id?      uint32
                       |  |     +--rw cos-for-cfm-pdus?   uint32
                       |  |     +--rw ccm-interval?       uint32
                       |  |     +--rw ccm-holdtime?       uint32
                       |  |     +--rw ccm-p-bits-pri?
                       |  |             ccm-priority-type
                       |  +--rw y-1731* [maid]
                       |     +--rw maid               string
                       |     +--rw mep-id?            uint32
                       |     +--rw pm-type?           identityref
                       |     +--rw remote-mep-id?     uint32
                       |     +--rw message-period?    uint32
                       |     +--rw measurement-interval?   uint32
                       |     +--rw cos?        uint32
                       |     +--rw loss-measurement?      boolean
                       |     +--rw synthetic-loss-measurement?
                       |     |       boolean
                       |     +--rw delay-measurement
                       |     |  +--rw enable-dm?   boolean
                       |     |  +--rw two-way?     boolean
                       |     +--rw frame-size?     uint32
                       |     +--rw session-type?   enumeration
                       ...

  +--rw l2vpn-ntw
     +--rw vpn-profiles
     |  ...
     +--rw vpn-services
        +--rw vpn-service* [vpn-id]
           ...
           +--rw vpn-nodes
              +--rw vpn-node* [vpn-node-id]
                 ...
                 +--rw vpn-network-accesses
                    +--rw vpn-network-access* [id]
                       ...
                       +--rw service
                          +--rw mtu?            uint32
                          +--rw svc-pe-to-ce-bandwidth
                          |       {vpn-common:inbound-bw}?
                          |  ...
                          +--rw svc-ce-to-pe-bandwidth
                          |       {vpn-common:outbound-bw}?
                          |  ...
                          +--rw qos {vpn-common:qos}?
                          |  ...
                          +--rw mac-policies
                          |  ...
                          +--rw broadcast-unknown-unicast-multicast
                             ...

module iana-bgp-l2-encaps {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:iana-bgp-l2-encaps";
  prefix iana-bgp-l2-encaps;

  organization
    "IANA";
  contact
    "Internet Assigned Numbers Authority

     Postal: ICANN
          12025 Waterfront Drive, Suite 300
          Los Angeles, CA  90094-2536
          United States of America
     Tel:    +1 310 301 5800
     <mailto:iana@iana.org>";
  description
    "This YANG module contains a collection of IANA-maintained YANG
     data types that are used for referring to BGP Layer 2
     encapsulation types.

     Copyright (c) 2022 IETF Trust and the persons identified as
     authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Revised BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC 9291; see
     the RFC itself for full legal notices.";

  revision 2022-09-20 {
    description
      "First revision.";
    reference
      "RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }

  identity bgp-l2-encaps-type {
    description
      "Base BGP Layer 2 encapsulation type.";
    reference
      "RFC 6624: Layer 2 Virtual Private Networks Using BGP for
                 Auto-Discovery and Signaling";
  }

  identity frame-relay {
    base bgp-l2-encaps-type;
    description
      "Frame Relay.";
    reference
      "RFC 4446: IANA Allocations for Pseudowire Edge
                 to Edge Emulation (PWE3)";
  }

  identity atm-aal5 {
    base bgp-l2-encaps-type;
    description
      "ATM AAL5 SDU VCC transport.";
    reference
      "RFC 4446: IANA Allocations for Pseudowire Edge
                 to Edge Emulation (PWE3)";
  }

  identity atm-cell {
    base bgp-l2-encaps-type;
    description
      "ATM transparent cell transport.";
    reference
      "RFC 4816: Pseudowire Emulation Edge-to-Edge (PWE3)
                 Asynchronous Transfer Mode (ATM) Transparent
                 Cell Transport Service";
  }

  identity ethernet-tagged-mode {
    base bgp-l2-encaps-type;
    description
      "Ethernet (VLAN) Tagged Mode.";
    reference
      "RFC 4448: Encapsulation Methods for Transport of Ethernet
                 over MPLS Networks";
  }

  identity ethernet-raw-mode {
    base bgp-l2-encaps-type;
    description
      "Ethernet Raw Mode.";
    reference
      "RFC 4448: Encapsulation Methods for Transport of Ethernet
                 over MPLS Networks";
  }

  identity hdlc {
    base bgp-l2-encaps-type;
    description
      "Cisco HDLC.";
    reference
      "RFC 4618: Encapsulation Methods for Transport of
                 PPP/High-Level Data Link Control (HDLC)
                 over MPLS Networks";
  }

  identity ppp {
    base bgp-l2-encaps-type;
    description
      "PPP.";
    reference
      "RFC 4618: Encapsulation Methods for Transport of
                 PPP/High-Level Data Link Control (HDLC)
                 over MPLS Networks";
  }

  identity circuit-emulation {
    base bgp-l2-encaps-type;
    description
      "SONET/SDH Circuit Emulation Service.";
    reference
      "RFC 4842: Synchronous Optical Network/Synchronous Digital
                 Hierarchy (SONET/SDH) Circuit Emulation over Packet
                 (CEP)";
  }

  identity atm-to-vcc {
    base bgp-l2-encaps-type;
    description
      "ATM n-to-one VCC cell transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity atm-to-vpc {
    base bgp-l2-encaps-type;
    description
      "ATM n-to-one VPC cell transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity layer-2-transport {
    base bgp-l2-encaps-type;
    description
      "IP Layer 2 Transport.";
    reference
      "RFC 3032: MPLS Label Stack Encoding";
  }

  identity fr-port-mode {
    base bgp-l2-encaps-type;
    description
      "Frame Relay Port mode.";
    reference
      "RFC 4619: Encapsulation Methods for Transport of Frame Relay
                 over Multiprotocol Label Switching (MPLS)
                 Networks";
  }

  identity e1 {
    base bgp-l2-encaps-type;
    description
      "Structure-agnostic E1 over packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity t1 {
    base bgp-l2-encaps-type;
    description
      "Structure-agnostic T1 (DS1) over packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity vpls {
    base bgp-l2-encaps-type;
    description
      "VPLS.";
    reference
      "RFC 4761: Virtual Private LAN Service (VPLS)
                 Using BGP for Auto-Discovery and Signaling";
  }

  identity t3 {
    base bgp-l2-encaps-type;
    description
      "Structure-agnostic T3 (DS3) over packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity structure-aware {
    base bgp-l2-encaps-type;
    description
      "Nx64kbit/s Basic Service using Structure-aware.";
    reference
      "RFC 5086: Structure-Aware Time Division Multiplexed (TDM)
                 Circuit Emulation Service over Packet Switched
                 Network (CESoPSN)";
  }

  identity dlci {
    base bgp-l2-encaps-type;
    description
      "Frame Relay DLCI.";
    reference
      "RFC 4619: Encapsulation Methods for Transport of Frame Relay
                 over Multiprotocol Label Switching (MPLS)
                 Networks";
  }

  identity e3 {
    base bgp-l2-encaps-type;
    description
      "Structure-agnostic E3 over packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity ds1 {
    base bgp-l2-encaps-type;
    description
      "Octet-aligned payload for Structure-agnostic DS1 circuits.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity cas {
    base bgp-l2-encaps-type;
    description
      "E1 Nx64kbit/s with CAS using Structure-aware.";
    reference
      "RFC 5086: Structure-Aware Time Division Multiplexed (TDM)
                 Circuit Emulation Service over Packet Switched
                 Network (CESoPSN)";
  }

  identity esf {
    base bgp-l2-encaps-type;
    description
      "DS1 (ESF) Nx64kbit/s with CAS using Structure-aware.";
    reference
      "RFC 5086: Structure-Aware Time Division Multiplexed (TDM)
                 Circuit Emulation Service over Packet Switched
                 Network (CESoPSN)";
  }

  identity sf {
    base bgp-l2-encaps-type;
    description
      "DS1 (SF) Nx64kbit/s with CAS using Structure-aware.";
    reference
      "RFC 5086: Structure-Aware Time Division Multiplexed (TDM)
                 Circuit Emulation Service over Packet Switched
                 Network (CESoPSN)";
  }
}

module iana-pseudowire-types {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:iana-pseudowire-types";
  prefix iana-pw-types;

  organization
    "IANA";
  contact
    "Internet Assigned Numbers Authority

     Postal: ICANN
          12025 Waterfront Drive, Suite 300
          Los Angeles, CA  90094-2536
          United States of America
     Tel:    +1 310 301 5800
     <mailto:iana@iana.org>";
  description
    "This module contains a collection of IANA-maintained YANG
     data types that are used for referring to Pseudowire Types.

     Copyright (c) 2022 IETF Trust and the persons identified as
     authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Revised BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC 9291; see
     the RFC itself for full legal notices.";

  revision 2022-09-20 {
    description
      "First revision.";
    reference
      "RFC RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }

  identity iana-pw-types {
    description
      "Base Pseudowire Layer 2 encapsulation type.";
  }

  identity frame-relay {
    base iana-pw-types;
    description
      "Frame Relay DLCI (Martini Mode).";
    reference
      "RFC 4619: Encapsulation Methods for Transport of Frame Relay
                 over Multiprotocol Label Switching (MPLS)
                 Networks";
  }

  identity atm-aal5 {
    base iana-pw-types;
    description
      "ATM AAL5 SDU VCC transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity atm-cell {
    base iana-pw-types;
    description
      "ATM transparent cell transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity ethernet-tagged-mode {
    base iana-pw-types;
    description
      "Ethernet (VLAN) Tagged Mode.";
    reference
      "RFC 4448: Encapsulation Methods for Transport of Ethernet
                 over MPLS Networks";
  }

  identity ethernet {
    base iana-pw-types;
    description
      "Ethernet.";
    reference
      "RFC 4448: Encapsulation Methods for Transport of Ethernet
                 over MPLS Networks";
  }

  identity hdlc {
    base iana-pw-types;
    description
      "HDLC.";
    reference
      "RFC 4618: Encapsulation Methods for Transport of
                 PPP/High-Level Data Link Control (HDLC)
                 over MPLS Networks";
  }

  identity ppp {
    base iana-pw-types;
    description
      "PPP.";
    reference
      "RFC 4618: Encapsulation Methods for Transport of
                 PPP/High-Level Data Link Control (HDLC)
                 over MPLS Networks";
  }

  identity circuit-emulation-mpls {
    base iana-pw-types;
    description
      "SONET/SDH Circuit Emulation Service Over MPLS Encapsulation.";
    reference
      "RFC 5143: Synchronous Optical Network/Synchronous Digital
                 Hierarchy (SONET/SDH) Circuit Emulation Service over
                 MPLS (CEM) Encapsulation";
  }

  identity atm-to-vcc {
    base iana-pw-types;
    description
      "ATM n-to-one VCC cell transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity atm-to-vpc {
    base iana-pw-types;
    description
      "ATM n-to-one VPC cell transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity layer-2-transport {
    base iana-pw-types;
    description
      "IP Layer2 Transport.";
    reference
      "RFC 3032: MPLS Label Stack Encoding";
  }

  identity atm-one-to-one-vcc {
    base iana-pw-types;
    description
      "ATM one-to-one VCC Cell Mode.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity atm-one-to-one-vpc {
    base iana-pw-types;
    description
      "ATM one-to-one VPC Cell Mode.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity atm-aal5-vcc {
    base iana-pw-types;
    description
      "ATM AAL5 PDU VCC transport.";
    reference
      "RFC 4717: Encapsulation Methods for Transport of
                 Asynchronous Transfer Mode (ATM) over MPLS
                 Networks";
  }

  identity fr-port-mode {
    base iana-pw-types;
    description
      "Frame-Relay Port mode.";
    reference
      "RFC 4619: Encapsulation Methods for Transport of Frame Relay
                 over Multiprotocol Label Switching (MPLS)
                 Networks";
  }

  identity circuit-emulation-packet {
    base iana-pw-types;
    description
      "SONET/SDH Circuit Emulation over Packet.";
    reference
      "RFC 4842: Synchronous Optical Network/Synchronous Digital
                 Hierarchy (SONET/SDH) Circuit Emulation over Packet
                 (CEP)";
  }

  identity e1 {
    base iana-pw-types;
    description
      "Structure-agnostic E1 over Packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity t1 {
    base iana-pw-types;
    description
      "Structure-agnostic T1 (DS1) over Packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity e3 {
    base iana-pw-types;
    description
      "Structure-agnostic E3 over Packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity t3 {
    base iana-pw-types;
    description
      "Structure-agnostic T3 (DS3) over Packet.";
    reference
      "RFC 4553: Structure-Agnostic Time Division Multiplexing (TDM)
                 over Packet (SAToP)";
  }

  identity ces-over-psn {
    base iana-pw-types;
    description
      "CESoPSN basic mode.";
    reference
      "RFC 5086: Structure-Aware Time Division Multiplexed (TDM)
                 Circuit Emulation Service over Packet Switched
                 Network (CESoPSN)";
  }

  identity tdm-over-ip-aal1 {
    base iana-pw-types;
    description
      "TDMoIP AAL1 Mode.";
    reference
      "RFC 5087: Time Division Multiplexing over IP (TDMoIP)";
  }

  identity ces-over-psn-cas {
    base iana-pw-types;
    description
      "CESoPSN TDM with CAS.";
    reference
      "RFC 5086: Structure-Aware Time Division Multiplexed (TDM)
                 Circuit Emulation Service over Packet Switched
                 Network (CESoPSN)";
  }

  identity tdm-over-ip-aal2 {
    base iana-pw-types;
    description
      "TDMoIP AAL2 Mode.";
    reference
      "RFC 5087: Time Division Multiplexing over IP (TDMoIP)";
  }

  identity dlci {
    base iana-pw-types;
    description
      "Frame Relay DLCI.";
    reference
      "RFC 4619: Encapsulation Methods for Transport of Frame Relay
                 over Multiprotocol Label Switching (MPLS)
                 Networks";
  }

  identity rohc {
    base iana-pw-types;
    description
      "ROHC Transport Header-compressed Packets.";
    reference
      "RFC 5795: The RObust Header Compression (ROHC) Framework
       RFC 4901: Protocol Extensions for Header Compression over
                 MPLS";
  }

  identity ecrtp {
    base iana-pw-types;
    description
      "ECRTP Transport Header-compressed Packets.";
    reference
      "RFC 3545: Enhanced Compressed RTP (CRTP) for Links with High
                 Delay, Packet Loss and Reordering
       RFC 4901: Protocol Extensions for Header Compression over
                 MPLS";
  }

  identity iphc {
    base iana-pw-types;
    description
      "IPHC Transport Header-compressed Packets.";
    reference
      "RFC 2507: IP Header Compression
       RFC 4901: Protocol Extensions for Header Compression over
                 MPLS";
  }

  identity crtp {
    base iana-pw-types;
    description
      "cRTP Transport Header-compressed Packets.";
    reference
      "RFC 2508: Compressing IP/UDP/RTP Headers for Low-Speed Serial
                 Links
       RFC 4901: Protocol Extensions for Header Compression over
                 MPLS";
  }

  identity atm-vp-virtual-trunk {
    base iana-pw-types;
    description
      "ATM VP Virtual Trunk.";
    reference
      "MFA Forum: The Use of Virtual Trunks for ATM/MPLS
                  Control Plane Interworking Specification";
  }

  identity fc-port-mode {
    base iana-pw-types;
    description
      "FC Port Mode.";
    reference
      "RFC 6307: Encapsulation Methods for Transport of
                 Fibre Channel Traffic over MPLS Networks";
  }

  identity wildcard {
    base iana-pw-types;
    description
      "Wildcard.";
    reference
      "RFC 4863: Wildcard Pseudowire Type";
  }
}

module ietf-ethernet-segment {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:ietf-ethernet-segment";
  prefix l2vpn-es;

  import ietf-yang-types {
    prefix yang;
    reference
      "RFC 6991: Common YANG Data Types (see Section 3)";
  }

  organization
    "IETF OPSA (Operations and Management Area) Working Group";
  contact
    "WG Web:   <https://datatracker.ietf.org/wg/opsawg/>
     WG List:  <mailto:opsawg@ietf.org>

     Editor:    Mohamed Boucadair
               <mailto:mohamed.boucadair@orange.com>

     Editor:    Samier Barguil
               <mailto:samier.barguilgiraldo.ext@telefonica.com>

     Author:    Oscar Gonzalez de Dios
               <mailto:oscar.gonzalezdedios@telefonica.com>";

  description
    "This YANG module defines a model for Ethernet Segments.

     Copyright (c) 2022 IETF Trust and the persons identified as
     authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Revised BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC 9291; see
     the RFC itself for full legal notices.";

  revision 2022-09-20 {
    description
      "Initial version.";
    reference
      "RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }

  /* Typedefs */

  typedef es-ref {
    type leafref {
      path "/l2vpn-es:ethernet-segments/l2vpn-es:ethernet-segment"
         + "/l2vpn-es:name";
    }
    description
      "Defines a type for referencing an Ethernet segment in
       other modules.";
  }

  /* Identities */

  identity esi-type {
    description
      "T (Ethernet Segment Identifier (ESI) Type) is a 1-octet field
       (most significant octet) that specifies the format of the
       remaining 9 octets (ESI Value).";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 5";
  }

  identity esi-type-0-operator {
    base esi-type;
    description
      "This type indicates an arbitrary 9-octet ESI value,
       which is managed and configured by the operator.";
  }

  identity esi-type-1-lacp {
    base esi-type;
    description
      "When the IEEE 802.1AX Link Aggregation Control Protocol (LACP)
       is used between the Provider Edge (PE) and Customer Edge (CE)
       devices, this ESI type indicates an auto-generated ESI value
       determined from LACP.";
    reference
      "IEEE Std 802.1AX: Link Aggregation";
  }

  identity esi-type-2-bridge {
    base esi-type;
    description
      "The ESI value is auto-generated and determined based
       on the Layer 2 bridge protocol.";
  }

  identity esi-type-3-mac {
    base esi-type;
    description
      "This type indicates a MAC-based ESI value that can be
       auto-generated or configured by the operator.";
  }

  identity esi-type-4-router-id {
    base esi-type;
    description
      "This type indicates a Router ID ESI value that can be
       auto-generated or configured by the operator.";
  }

  identity esi-type-5-asn {
    base esi-type;
    description
      "This type indicates an Autonomous System (AS)-based ESI value
       that can be auto-generated or configured by the operator.";
  }

  identity df-election-methods {
    description
      "Base Identity Designated Forwarder (DF) election method.";
  }

  identity default-7432 {
    base df-election-methods;
    description
      "The default DF election method.

       The default procedure for DF election at the granularity of
       <ES,VLAN> for VLAN-based service or <ES, VLAN bundle> for
       VLAN-(aware) bundle service is referred to as
       'service carving'.";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 8.5";
  }

  identity highest-random-weight {
    base df-election-methods;
    description
      "The highest random weight (HRW) method.";
    reference
      "RFC 8584: Framework for Ethernet VPN Designated
                 Forwarder Election Extensibility, Section 3";
  }

  identity preference {
    base df-election-methods;
    description
      "The preference-based method.  PEs are assigned with
       preferences to become the DF in the Ethernet Segment (ES).
       The exact preference-based algorithm (e.g., lowest-preference
       algorithm or highest-preference algorithm) to use is
       signaled at the control plane.";
  }

  identity es-redundancy-mode {
    description
      "Base identity for ES redundancy modes.";
  }

  identity single-active {
    base es-redundancy-mode;
    description
      "Indicates Single-Active redundancy mode for a given ES.";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 14.1.1";
  }

  identity all-active {
    base es-redundancy-mode;
    description
      "Indicates All-Active redundancy mode for a given ES.";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 14.1.2";
  }

  /* Main Ethernet Segment Container */

  container ethernet-segments {
    description
      "Top container for the Ethernet Segment Identifier (ESI).";
    list ethernet-segment {
      key "name";
      description
        "Top list for ESIs.";
      leaf name {
        type string;
        description
          "Includes the name of the Ethernet Segment (ES) that
           is used to unambiguously identify an ES.";
      }
      leaf esi-type {
        type identityref {
          base esi-type;
        }
        default "esi-type-0-operator";
        description
          "T-(ESI Type) is a 1-octet field (most significant
           octet) that specifies the format of the remaining
           9 octets (ESI Value).";
        reference
          "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 5";
      }
      choice esi-choice {
        description
          "Ethernet segment choice between several types.
           For ESI Type 0: The esi is directly configured by the
                           operator.
           For ESI Type 1: The auto-mode must be used.
           For ESI Type 2: The auto-mode must be used.
           For ESI Type 3: The directly-assigned or auto-mode must
                           be used.
           For ESI Type 4: The directly-assigned or auto-mode must
                           be used.
           For ESI Type 5: The directly-assigned or auto-mode must
                           be used.";
        case directly-assigned {
          description
            "Explicitly assign an ESI value.";
          leaf ethernet-segment-identifier {
            type yang:hex-string {
              length "29";
            }
            description
              "10-octet ESI.";
          }
        }
        case auto-assigned {
          description
            "The ESI is auto-assigned.";
          container esi-auto {
            description
              "The ESI is auto-assigned.";
            choice auto-mode {
              description
                "Indicates the auto-assignment mode.  ESI can be
                 automatically assigned either with or without
                 indicating a pool from which the ESI should be
                 taken.

                 For both cases, the server will auto-assign an
                 ESI value 'auto-assigned-ESI' and use that value
                 operationally.";
              case from-pool {
                leaf esi-pool-name {
                  type string;
                  description
                    "The auto-assignment will be made from the
                     pool identified by the ESI-pool-name.";
                }
              }
              case full-auto {
                leaf auto {
                  type empty;
                  description
                    "Indicates an ESI is fully auto-assigned.";
                }
              }
            }
            leaf auto-ethernet-segment-identifier {
              type yang:hex-string {
                length "29";
              }
              config false;
              description
                "The value of the auto-assigned ESI.";
            }
          }
        }
      }
      leaf esi-redundancy-mode {
        type identityref {
          base es-redundancy-mode;
        }
        description
          "Indicates the ES redundancy mode.";
        reference
          "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 14.1";
      }
      container df-election {
        description
          "Top container for the DF election method properties.";
        leaf df-election-method {
          type identityref {
            base df-election-methods;
          }
          default "default-7432";
          description
            "Specifies the DF election method.";
          reference
            "RFC 8584: Framework for Ethernet VPN Designated
                       Forwarder Election Extensibility";
        }
        leaf revertive {
          when "derived-from-or-self(../df-election-method, "
             + "'preference')" {
            description
              "The revertive value is only applicable
               to the preference method.";
          }
          type boolean;
          default "true";
          description
            "The default behavior is that the DF election
             procedure is triggered upon PE failures following
             configured preference values.  Such a mode is called
             the 'revertive' mode.  This mode may not be suitable in
             some scenarios where, e.g., an operator may want to
             maintain the new DF even if the former DF recovers.
             Such a mode is called the 'non-revertive' mode.

             The non-revertive mode can be configured by
             setting 'revertive' leaf to 'false'.";
          reference
            "RFC 8584: Framework for Ethernet VPN Designated
                       Forwarder Election Extensibility,
                       Section 1.3.2";
        }
        leaf election-wait-time {
          type uint32;
          units "seconds";
          default "3";
          description
            "Designated Forwarder Wait timer.";
          reference
            "RFC 8584: Framework for Ethernet VPN Designated
                       Forwarder Election Extensibility";
        }
      }
      leaf split-horizon-filtering {
        type boolean;
        description
          "Controls split-horizon filtering.  It is enabled
           when set to 'true'.

           In order to achieve split-horizon filtering, every
           Broadcast, Unknown Unicast, or Multicast (BUM)
           packet originating from a non-DF PE is encapsulated
           with an MPLS label that identifies the origin ES.";
        reference
          "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 8.3";
      }
      container pbb {
        description
          "Provider Backbone Bridging (PBB) parameters .";
        reference
          "IEEE 802.1ah: Provider Backbone Bridges";
        leaf backbone-src-mac {
          type yang:mac-address;
          description
            "The PEs connected to the same CE must share the
             same Provider Backbone (B-MAC) address in
             All-Active mode.";
          reference
            "RFC 7623: Provider Backbone Bridging Combined with
                       Ethernet VPN (PBB-EVPN), Section 6.2.1.1";
        }
      }
      list member {
        key "ne-id interface-id";
        description
          "Includes a list of ES members.";
        leaf ne-id {
          type string;
          description
            "An identifier of the network element where the ES
             is configured within a service provider network.";
        }
        leaf interface-id {
          type string;
          description
            "Identifier of a node interface.";
        }
      }
    }
  }
}

module ietf-l2vpn-ntw {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:ietf-l2vpn-ntw";
  prefix l2vpn-ntw;

  import ietf-inet-types {
    prefix inet;
    reference
      "RFC 6991: Common YANG Data Types, Section 4";
  }
  import ietf-yang-types {
    prefix yang;
    reference
      "RFC 6991: Common YANG Data Types, Section 3";
  }
  import ietf-vpn-common {
    prefix vpn-common;
    reference
      "RFC 9181: A Common YANG for Data Model for Layer 2
                 and Layer 3 VPNs";
  }
  import iana-bgp-l2-encaps {
    prefix iana-bgp-l2-encaps;
    reference
      "RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }
  import iana-pseudowire-types {
    prefix iana-pw-types;
    reference
      "RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }
  import ietf-ethernet-segment {
    prefix l2vpn-es;
    reference
      "RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }
  import ietf-routing-types {
    prefix rt-types;
    reference
      "RFC 8294: Common YANG Data Types for the Routing Area";
  }
  import ieee802-dot1q-types {
    prefix dot1q-types;
    reference
      "IEEE Std 802.1Qcp: Bridges and Bridged Networks--
                          Amendment 30: YANG Data Model";
  }

  organization
    "IETF OPSA (Operations and Management Area) Working Group";
  contact
    "WG Web:   <https://datatracker.ietf.org/wg/opsawg/>
     WG List:  <mailto:opsawg@ietf.org>

     Editor:    Mohamed Boucadair
               <mailto:mohamed.boucadair@orange.com>

     Editor:    Samier Barguil
               <mailto:samier.barguilgiraldo.ext@telefonica.com>

     Author:    Oscar Gonzalez de Dios
               <mailto:oscar.gonzalezdedios@telefonica.com>";

  description
    "This YANG module defines a network model for Layer 2 VPN
     services.

     Copyright (c) 2022 IETF Trust and the persons identified as
     authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Revised BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC 9291; see
     the RFC itself for full legal notices.";

  revision 2022-09-20 {
    description
      "Initial version.";
    reference
      "RFC 9291: A YANG Network Data Model for Layer 2 VPNs.";
  }

  /* Features */

  feature oam-3ah {
    description
      "Indicates the support of OAM 802.3ah.";
    reference
      "IEEE Std 802.3ah: Media Access Control Parameters, Physical
                         Layers, and  Management Parameters for
                         Subscriber Access Networks";
  }

  /* Identities */

  identity evpn-service-interface-type {
    description
      "Base identity for EVPN service interface type.";
  }

  identity vlan-based-service-interface {
    base evpn-service-interface-type;
    description
      "VLAN-based service interface.";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 6.1";
  }

  identity vlan-bundle-service-interface {
    base evpn-service-interface-type;
    description
      "VLAN bundle service interface.";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 6.2";
  }

  identity vlan-aware-bundle-service-interface {
    base evpn-service-interface-type;
    description
      "VLAN-aware bundle service interface.";
    reference
      "RFC 7432: BGP MPLS-Based Ethernet VPN, Section 6.3";
  }

  identity mapping-type {
    base vpn-common:multicast-gp-address-mapping;
    description
      "Identity for multicast group mapping type.";
  }

  identity loop-prevention-type {
    description
      "Identity of loop prevention.";
  }

  identity shut {
    base loop-prevention-type;
    description
      "Shut protection type.";
  }

  identity trap {
    base loop-prevention-type;
    description
      "Trap protection type.";
  }

  identity color-type {
    description
      "Identity of color types.  A type is assigned to a service
       frame to identify its QoS profile conformance.";
  }

  identity green {
    base color-type;
    description
      "'green' color type.  A service frame is 'green' if it is
       conformant with the committed rate of the bandwidth profile.";
  }

  identity yellow {
    base color-type;
    description
      "'yellow' color type.  A service frame is 'yellow' if it
       exceeds the committed rate but is conformant with the excess
       rate of the bandwidth profile.";
  }

  identity red {
    base color-type;
    description
      "'red' color type.  A service frame is 'red' if it is not
       conformant with both the committed and excess rates of the
       bandwidth profile.";
  }

  identity t-ldp-pw-type {
    description
      "Identity for T-LDP pseudowire (PW) type.";
  }

  identity vpws-type {
    base t-ldp-pw-type;
    description
      "Virtual Private Wire Service (VPWS) t-ldp-pw-type.";
    reference
      "RFC 4664: Framework for Layer 2 Virtual Private Networks
                (L2VPNs), Section 3.3";
  }

  identity vpls-type {
    base t-ldp-pw-type;
    description
      "Virtual Private LAN Service (VPLS) t-ldp-pw-type.";
    reference
      "RFC 4762: Virtual Private LAN Service (VPLS) Using
                 Label Distribution Protocol (LDP)
                 Signaling, Section 6.1";
  }

  identity hvpls {
    base t-ldp-pw-type;
    description
      "Identity for Hierarchical Virtual Private LAN Service (H-VPLS)
       t-ldp-pw-type.";
    reference
      "RFC 4762: Virtual Private LAN Service (VPLS) Using
                 Label Distribution Protocol (LDP)
                 Signaling, Section 10";
  }

  identity lacp-mode {
    description
      "Identity of the LACP mode.";
  }

  identity lacp-active {
    base lacp-mode;
    description
      "LACP active mode.

       This mode refers to the mode where auto-speed negotiation
       is initiated followed by an establishment of an
       Ethernet channel with the other end.";
  }

  identity lacp-passive {
    base lacp-mode;
    description
      "LACP passive mode.

       This mode refers to the LACP mode where an endpoint does
       not initiate the negotiation but only responds to LACP
       packets initiated by the other end (e.g., full duplex
       or half duplex)";
  }

  identity pm-type {
    description
      "Identity for performance monitoring type.";
  }

  identity loss {
    base pm-type;
    description
      "Loss measurement is the performance monitoring type.";
  }

  identity delay {
    base pm-type;
    description
      "Delay measurement is the performance monitoring type.";
  }

  identity mac-learning-mode {
    description
      "Media Access Control (MAC) learning mode.";
  }

  identity data-plane {
    base mac-learning-mode;
    description
      "User MAC addresses are learned through ARP broadcast.";
  }

  identity control-plane {
    base mac-learning-mode;
    description
      "User MAC addresses are advertised through EVPN-BGP.";
  }

  identity mac-action {
    description
      "Base identity for a MAC action.";
  }

  identity drop {
    base mac-action;
    description
      "Dropping a packet as the MAC action.";
  }

  identity flood {
    base mac-action;
    description
      "Packet flooding as the MAC action.";
  }

  identity warning {
    base mac-action;
    description
      "Log a warning message as the MAC action.";
  }

  identity precedence-type {
    description
      "Redundancy type.  The service can be created
       with primary and secondary signalization.";
  }

  identity primary {
    base precedence-type;
    description
      "Identifies the main VPN network access.";
  }

  identity secondary {
    base precedence-type;
    description
      "Identifies the secondary VPN network access.";
  }

  identity ldp-pw-type {
    description
      "Identity for allowed LDP-based pseudowire (PW) type.";
    reference
      "RFC 4762: Virtual Private LAN Service (VPLS) Using
                 Label Distribution Protocol (LDP)
                 Signaling, Section 6.1.1";
  }

  identity ethernet {
    base ldp-pw-type;
    description
      "PW Ethernet type.";
  }

  identity ethernet-tagged {
    base ldp-pw-type;
    description
      "PW Ethernet tagged mode type.";
  }

  /* Typedefs */

  typedef ccm-priority-type {
    type uint8 {
      range "0..7";
    }
    description
      "A 3-bit priority value to be used in the VLAN tag
       if present in the transmitted frame.  A larger value
       indicates a higher priority.";
  }

  /* Groupings */

  grouping cfm-802 {
    description
      "Grouping for 802.1ag Connectivity Fault Management (CFM)
       attributes.";
    reference
      "IEEE Std 802.1ag: Virtual Bridged Local Area Networks
                         Amendment 5: Connectivity Fault Management";
    leaf maid {
      type string;
      description
        "Maintenance Association Identifier (MAID).";
    }
    leaf mep-id {
      type uint32;
      description
        "Local Maintenance Entity Group End Point (MEP) ID.";
    }
    leaf mep-level {
      type uint32;
      description
        "MEP level.";
    }
    leaf mep-up-down {
      type enumeration {
        enum up {
          description
            "MEP is up.";
        }
        enum down {
          description
            "MEP is down.";
        }
      }
      default "up";
      description
        "MEP up/down.";
    }
    leaf remote-mep-id {
      type uint32;
      description
        "Remote MEP ID.";
    }
    leaf cos-for-cfm-pdus {
      type uint32;
      description
        "Class of Service for CFM PDUs.";
    }
    leaf ccm-interval {
      type uint32;
      units "milliseconds";
      default "10000";
      description
        "Continuity Check Message (CCM) interval.";
    }
    leaf ccm-holdtime {
      type uint32;
      units "milliseconds";
      default "35000";
      description
        "CCM hold time.";
    }
    leaf ccm-p-bits-pri {
      type ccm-priority-type;
      description
        "The priority parameter for CCMs
         transmitted by the MEP.";
    }
  }

  grouping y-1731 {
    description
      "Grouping for Y-1731";
    reference
      "ITU-T G.8013/Y.1731:  Operations, administration and
                             maintenance (OAM) functions and
                             mechanisms for Ethernet-based
                             networks";
    list y-1731 {
      key "maid";
      description
        "List of configured Y-1731 instances.";
      leaf maid {
        type string;
        description
          "MAID.";
      }
      leaf mep-id {
        type uint32;
        description
          "Local MEP ID.";
      }
      leaf pm-type {
        type identityref {
          base pm-type;
        }
        default "delay";
        description
          "Performance monitor types.";
      }
      leaf remote-mep-id {
        type uint32;
        description
          "Remote MEP ID.";
      }
      leaf message-period {
        type uint32;
        units "milliseconds";
        default "10000";
        description
          "Defines the interval between OAM messages.";
      }
      leaf measurement-interval {
        type uint32;
        units "seconds";
        description
          "Specifies the measurement interval for statistics.";
      }
      leaf cos {
        type uint32;
        description
          "Identifies the Class of Service.";
      }
      leaf loss-measurement {
        type boolean;
        default "false";
        description
          "Controls whether loss measurement is ('true') or
           disabled ('false').";
      }
      leaf synthetic-loss-measurement {
        type boolean;
        default "false";
        description
          "Indicates whether synthetic loss measurement is
           enabled ('true') or disabled ('false').";
      }
      container delay-measurement {
        description
          "Container for delay measurement.";
        leaf enable-dm {
          type boolean;
          default "false";
          description
            "Controls whether delay measurement is enabled
             ('true') or disabled ('false').";
        }
        leaf two-way {
          type boolean;
          default "false";
          description
            "Whether delay measurement is two-way ('true') of one-
             way ('false').";
        }
      }
      leaf frame-size {
        type uint32;
        units "bytes";
        description
          "Indicates the frame size.";
      }
      leaf session-type {
        type enumeration {
          enum proactive {
            description
              "Proactive mode.";
          }
          enum on-demand {
            description
              "On-demand mode.";
          }
        }
        default "on-demand";
        description
          "Specifies the session type.";
      }
    }
  }

  grouping parameters-profile {
    description
      "Container for per-service parameters.";
    leaf local-autonomous-system {
      type inet:as-number;
      description
        "Indicates a local AS Number (ASN).";
    }
    leaf svc-mtu {
      type uint32;
      units "bytes";
      description
        "Layer 2 service MTU.  It is also known
         as the maximum transmission unit or
         maximum frame size.";
    }
    leaf ce-vlan-preservation {
      type boolean;
      description
        "Preserves the CE VLAN ID from ingress to egress, i.e.,
         the CE VLAN tag of the egress frame is identical to
         that of the ingress frame that yielded this egress
         service frame.  If all-to-one bundling within a site
         is enabled, then preservation applies to all ingress
         service frames.  If all-to-one bundling is disabled,
         then preservation applies to tagged ingress service
         frames having CE VLAN ID 1 through 4094.";
    }
    leaf ce-vlan-cos-preservation {
      type boolean;
      description
        "CE VLAN CoS preservation.  Priority Code Point (PCP) bits
         in the CE VLAN tag of the egress frame are identical to
         those of the ingress frame that yielded this egress
         service frame.";
    }
    leaf control-word-negotiation {
      type boolean;
      description
        "Controls whether control-word negotiation is enabled
         (if set to true) or not (if set to false).";
      reference
        "RFC 8077: Pseudowire Setup and Maintenance
                   Using the Label Distribution Protocol (LDP),
                   Section 7";
    }
    container mac-policies {
      description
        "Container of MAC policies.";
      container mac-addr-limit {
        description
          "Container of MAC address limit configuration.";
        leaf limit-number {
          type uint16;
          description
            "Maximum number of MAC addresses learned from
             the customer for a single service instance.
             The default value is '2' when this grouping
             is used at the service level.";
        }
        leaf time-interval {
          type uint32;
          units "milliseconds";
          description
            "The aging time of the MAC address.
             The default value is '300' when this grouping
             is used at the service level.";
        }
        leaf action {
          type identityref {
            base mac-action;
          }
          description
            "Specifies the action when the upper limit is
             exceeded: drop the packet, flood the packet,
             or log a warning message (without dropping
             the packet).
             The default value is 'warning' when this
             grouping is used at the service level.";
        }
      }
      container mac-loop-prevention {
        description
          "Container for MAC loop prevention.";
        leaf window {
          type uint32;
          units "seconds";
          description
            "The time interval over which a MAC mobility event
             is detected and checked.
             The default value is '180' when this grouping
             is used at the service level.";
        }
        leaf frequency {
          type uint32;
          description
            "The number of times to detect MAC duplication, where
             a 'duplicate MAC address' situation has occurred
             within the 'window' time interval and the duplicate
             MAC address has been added to a list of duplicate
             MAC addresses.
             The default value is '5' when this grouping is
             called at the service level.";
        }
        leaf retry-timer {
          type uint32;
          units "seconds";
          description
            "The retry timer.  When the retry timer expires,
             the duplicate MAC address will be flushed from
             the MAC-VRF.";
        }
        leaf protection-type {
          type identityref {
            base loop-prevention-type;
          }
          description
            "Protection type.
             The default value is 'trap' when this grouping
             is used at the service level.";
        }
      }
    }
    container multicast {
      if-feature "vpn-common:multicast";
      description
        "Multicast container.";
      leaf enabled {
        type boolean;
        default "false";
        description
          "Enables multicast.";
      }
      container customer-tree-flavors {
        description
          "Type of trees used by the customer.";
        leaf-list tree-flavor {
          type identityref {
            base vpn-common:multicast-tree-type;
          }
          description
            "Type of multicast tree to be used.";
        }
      }
    }
  }

  grouping bandwidth-parameters {
    description
      "A grouping for bandwidth parameters.";
    leaf cir {
      type uint64;
      units "bps";
      description
        "Committed Information Rate (CIR).  The maximum
         number of bits that a port can receive or
         send during one second over an
         interface.";
    }
    leaf cbs {
      type uint64;
      units "bytes";
      description
        "Committed Burst Size (CBS).  CBS controls the
         bursty nature of the traffic.  Traffic
         that does not use the configured CIR
         accumulates credits until the credits
         reach the configured CBS.";
    }
    leaf eir {
      type uint64;
      units "bps";
      description
        "Excess Information Rate (EIR), i.e., excess
         frame delivery allowed not subject to
         a Service Level Agreement (SLA).  The
         traffic rate can be limited by EIR.";
    }
    leaf ebs {
      type uint64;
      units "bytes";
      description
        "Excess Burst Size (EBS).  The bandwidth
         available for burst traffic from the
         EBS is subject to the amount of
         bandwidth that is accumulated during
         periods when traffic allocated by the
         EIR policy is not used.";
    }
    leaf pir {
      type uint64;
      units "bps";
      description
        "Peak Information Rate (PIR), i.e., maximum
         frame delivery allowed.  It is equal
         to or less than sum of CIR and EIR.";
    }
    leaf pbs {
      type uint64;
      units "bytes";
      description
        "Peak Burst Size (PBS).";
    }
  }

  /* Main L2NM Container */

  container l2vpn-ntw {
    description
      "Container for the L2NM.";
    container vpn-profiles {
      description
        "Container for VPN profiles.";
      uses vpn-common:vpn-profile-cfg;
    }
    container vpn-services {
      description
        "Container for L2VPN services.";
      list vpn-service {
        key "vpn-id";
        description
          "Container of a VPN service.";
        uses vpn-common:vpn-description;
        leaf parent-service-id {
          type vpn-common:vpn-id;
          description
            "Pointer to the parent service that
             triggered the L2NM.";
        }
        leaf vpn-type {
          type identityref {
            base vpn-common:service-type;
          }
          must "not(derived-from-or-self(current(), "
             + "'vpn-common:l3vpn'))" {
            error-message "L3VPN is only applicable in L3NM.";
          }
          description
            "Service type.";
        }
        leaf vpn-service-topology {
          type identityref {
            base vpn-common:vpn-topology;
          }
          description
            "Defines service topology such as
             any-to-any, hub-spoke, etc.";
        }
        leaf bgp-ad-enabled {
          type boolean;
          description
            "Indicates whether BGP auto-discovery is enabled
             or disabled.";
        }
        leaf signaling-type {
          type identityref {
            base vpn-common:vpn-signaling-type;
          }
          description
            "VPN signaling type.";
        }
        container global-parameters-profiles {
          description
            "Container for a list of global parameters
             profiles.";
          list global-parameters-profile {
            key "profile-id";
            description
              "List of global parameters profiles.";
            leaf profile-id {
              type string;
              description
                "The identifier of the global parameters profile.";
            }
            uses vpn-common:route-distinguisher;
            uses vpn-common:vpn-route-targets;
            uses parameters-profile;
          }
        }
        container underlay-transport {
          description
            "Container for the underlay transport.";
          uses vpn-common:underlay-transport;
        }
        uses vpn-common:service-status;
        container vpn-nodes {
          description
            "Set of VPN nodes that are involved in the L2NM.";
          list vpn-node {
            key "vpn-node-id";
            description
              "Container of the VPN nodes.";
            leaf vpn-node-id {
              type vpn-common:vpn-id;
              description
                "Sets the identifier of the VPN node.";
            }
            leaf description {
              type string;
              description
                "Textual description of a VPN node.";
            }
            leaf ne-id {
              type string;
              description
                "An identifier of the network element where
                 the VPN node is deployed.  This identifier
                 uniquely identifies the network element within
                 an administrative domain.";
            }
            leaf role {
              type identityref {
                base vpn-common:role;
              }
              default "vpn-common:any-to-any-role";
              description
                "Role of the VPN node in the VPN.";
            }
            leaf router-id {
              type rt-types:router-id;
              description
                "A 32-bit number in the dotted-quad format that is
                 used to uniquely identify a node within an
                 Autonomous System (AS).";
            }
            container active-global-parameters-profiles {
              description
                "Container for a list of global parameters
                 profiles.";
              list global-parameters-profile {
                key "profile-id";
                description
                  "List of active global parameters profiles.";
                leaf profile-id {
                  type leafref {
                    path "../../../../../global-parameters-profiles"
                       + "/global-parameters-profile/profile-id";
                  }
                  description
                    "Points to a global profile defined at the
                     service level.";
                }
                uses parameters-profile;
              }
            }
            uses vpn-common:service-status;
            container bgp-auto-discovery {
              when "../../../bgp-ad-enabled = 'true'" {
                description
                  "Only applies when BGP auto-discovery is enabled.";
              }
              description
                "BGP is used for auto-discovery.";
              choice bgp-type {
                description
                  "Choice for the BGP type.";
                case l2vpn-bgp {
                  description
                    "Container for BGP L2VPN.";
                  leaf vpn-id {
                    type vpn-common:vpn-id;
                    description
                      "VPN Identifier.  This identifier serves to
                       unify components of a given VPN for the
                       sake of auto-discovery.";
                    reference
                      "RFC 6624: Layer 2 Virtual Private Networks
                                 Using BGP for Auto-Discovery and
                                 Signaling";
                  }
                }
                case evpn-bgp {
                  description
                    "EVPN case.";
                  leaf evpn-type {
                    type leafref {
                      path "../../../../vpn-type";
                    }
                    description
                      "EVPN type.";
                  }
                  leaf auto-rt-enable {
                    type boolean;
                    default "false";
                    description
                      "Enables/disabled RT auto-derivation based on
                       the ASN and Ethernet Tag ID.";
                    reference
                      "RFC 7432: BGP MPLS-Based Ethernet VPN,
                                 Section 7.10.1";
                  }
                  leaf auto-route-target {
                    when "../auto-rt-enable = 'true'" {
                      description
                        "Can only be used when auto-RD is enabled.";
                    }
                    type rt-types:route-target;
                    config false;
                    description
                      "The value of the auto-assigned RT.";
                  }
                }
              }
              uses vpn-common:route-distinguisher;
              uses vpn-common:vpn-route-targets;
            }
            container signaling-option {
              description
                "Container for the L2VPN signaling.";
              leaf advertise-mtu {
                type boolean;
                description
                  "Controls whether MTU is advertised.";
                reference
                  "RFC 4667: Layer 2 Virtual Private Network (L2VPN)
                             Extensions for Layer 2 Tunneling
                             Protocol (L2TP), Section 4.3";
              }
              leaf mtu-allow-mismatch {
                type boolean;
                description
                  "When set to true, it allows MTU mismatch.";
                reference
                  "RFC 4667: Layer 2 Virtual Private Network (L2VPN)
                             Extensions for Layer 2 Tunneling
                             Protocol (L2TP), Section 4.3";
              }
              leaf signaling-type {
                type leafref {
                  path "../../../../signaling-type";
                }
                description
                  "VPN signaling type.";
              }
              choice signaling-option {
                description
                  "Choice for the signaling-option.";
                case bgp {
                  description
                    "BGP is used as the signaling protocol.";
                  choice bgp-type {
                    description
                      "Choice for the BGP type.";
                    case l2vpn-bgp {
                      description
                        "Container for BGP L2VPN.";
                      leaf ce-range {
                        type uint16;
                        description
                          "Determines the number of remote CEs with
                           which a given CE can communicate in the
                            context of a VPN.";
                        reference
                          "RFC 6624: Layer 2 Virtual Private Networks
                                     Using BGP for Auto-Discovery and
                                     Signaling";
                      }
                      leaf pw-encapsulation-type {
                        type identityref {
                          base iana-bgp-l2-encaps:bgp-l2-encaps-type;
                        }
                        description
                          "PW encapsulation type.";
                      }
                      container vpls-instance {
                        when "derived-from-or-self(../../../../"
                           + "vpn-type, 'vpn-common:vpls')" {
                          description
                            "Only applies for VPLS.";
                        }
                        description
                          "VPLS instance.";
                        leaf vpls-edge-id {
                          type uint16;
                          description
                            "VPLS Edge Identifier (VE ID).  This is
                             used when the same VE ID is configured
                             for the PE.";
                          reference
                            "RFC 4761: Virtual Private LAN Service
                                       (VPLS) Using BGP for Auto-
                                       Discovery and Signaling,
                                       Section 3.5";
                        }
                        leaf vpls-edge-id-range {
                          type uint16;
                          description
                            "Specifies the size of the range of
                             VE ID in a VPLS service. The range
                             controls the size of the label
                             block advertised in the context of
                             a VPLS instance.";
                          reference
                            "RFC 4761: Virtual Private LAN Service
                                       (VPLS) Using BGP for Auto-
                                       Discovery and Signaling";
                        }
                      }
                    }
                    case evpn-bgp {
                      description
                        "Used for EVPN.";
                      leaf evpn-type {
                        type leafref {
                          path "../../bgp-auto-discovery/evpn-type";
                        }
                        description
                          "EVPN type.";
                      }
                      leaf service-interface-type {
                        type identityref {
                          base evpn-service-interface-type;
                        }
                        description
                          "EVPN service interface type.";
                      }
                      container evpn-policies {
                        description
                          "Includes a set of EVPN policies such
                           as those related to handling MAC
                           addresses.";
                        leaf mac-learning-mode {
                          type identityref {
                            base mac-learning-mode;
                          }
                          description
                            "Indicates through which plane MAC
                             addresses are advertised.";
                        }
                        leaf ingress-replication {
                          type boolean;
                          description
                            "Controls whether ingress replication is
                             enabled ('true') or disabled
                             ('false').";
                          reference
                            "RFC 7432: BGP MPLS-Based Ethernet VPN,
                                       Section 8.3.1.1";
                        }
                        leaf p2mp-replication {
                          type boolean;
                          description
                            "Controls whether Point-to-Multipoint
                             (P2MP) replication is enabled ('true')
                             or disabled ('false')";
                          reference
                            "RFC 7432: BGP MPLS-Based Ethernet VPN,
                                       Section 8.3.1.2";
                        }
                        container arp-proxy {
                          if-feature "vpn-common:ipv4";
                          description
                            "Top container for the ARP proxy.";
                          leaf enable {
                            type boolean;
                            default "false";
                            description
                              "Enables (when set to 'true') or
                               disables (when set to 'false')
                               the ARP proxy.";
                            reference
                              "RFC 7432: BGP MPLS-Based Ethernet VPN,
                                         Section 10";
                          }
                          leaf arp-suppression {
                            type boolean;
                            default "false";
                            description
                              "Enables (when set to 'true') or
                               disables (when set to 'false') ARP
                               suppression.";
                            reference
                              "RFC 7432: BGP MPLS-Based Ethernet
                                         VPN";
                          }
                          leaf ip-mobility-threshold {
                            type uint16;
                            description
                              "It is possible for a given host (as
                               defined by its IP address) to move
                               from one ES to another.  The
                               IP mobility threshold specifies the
                               number of IP mobility events
                               that are detected for a given IP
                               address within the
                               detection-threshold before it
                               is identified as a duplicate IP
                               address.  Once the detection threshold
                               is reached, updates for the IP address
                               are suppressed.";
                          }
                          leaf duplicate-ip-detection-interval {
                            type uint16;
                            units "seconds";
                            description
                              "The time interval used in detecting a
                               duplicate IP address.  Duplicate IP
                               address detection number of host moves
                               are allowed within this interval
                               period.";
                          }
                        }
                        container nd-proxy {
                          if-feature "vpn-common:ipv6";
                          description
                            "Top container for the ND proxy.";
                          leaf enable {
                            type boolean;
                            default "false";
                            description
                              "Enables (when set to 'true') or
                               disables (when set to 'false') the
                               ND proxy.";
                            reference
                              "RFC 7432: BGP MPLS-Based Ethernet VPN,
                                         Section 10";
                          }
                          leaf nd-suppression {
                            type boolean;
                            default "false";
                            description
                              "Enables (when set to 'true') or
                               disables (when set to 'false')
                               Neighbor Discovery (ND) message
                               suppression.
                               ND suppression is a technique that
                               is used to reduce the amount of ND
                               packets flooding within individual
                               segments between hosts
                               connected to the same logical
                               switch.";
                          }
                          leaf ip-mobility-threshold {
                            type uint16;
                            description
                              "It is possible for a given host (as
                               defined by its IP address) to move
                               from one ES to another.  The
                               IP mobility threshold specifies the
                               number of IP mobility events
                               that are detected for a given IP
                               address within the
                               detection-threshold before it
                               is identified as a duplicate IP
                               address.
                               Once the detection threshold is
                               reached, updates for the IP address
                               are suppressed.";
                          }
                          leaf duplicate-ip-detection-interval {
                            type uint16;
                            units "seconds";
                            description
                              "The time interval used in detecting a
                               duplicate IP address.  Duplicate IP
                               address detection number of host moves
                               are allowed within this interval
                               period.";
                          }
                        }
                        leaf underlay-multicast {
                          type boolean;
                          default "false";
                          description
                            "Enables (when set to 'true') or disables
                             (when set to 'false') underlay
                             multicast.";
                        }
                        leaf flood-unknown-unicast-suppression {
                          type boolean;
                          default "false";
                          description
                            "Enables (when set to 'true') or disables
                             (when set to 'false') unknown flood
                             unicast suppression.";
                        }
                        leaf vpws-vlan-aware {
                          type boolean;
                          default "false";
                          description
                            "Enables (when set to 'true') or disables
                             (when set to 'false') VPWS VLAN-aware
                             service for the EVPN instance.";
                        }
                        container bum-management {
                          description
                            "Broadcast-unknown-unicast-multicast
                             management.";
                          leaf discard-broadcast {
                            type boolean;
                            default "false";
                            description
                              "Discards broadcast, when enabled.";
                          }
                          leaf discard-unknown-multicast {
                            type boolean;
                            default "false";
                            description
                              "Discards unknown multicast, when
                               enabled.";
                          }
                          leaf discard-unknown-unicast {
                            type boolean;
                            default "false";
                            description
                              "Discards unknown unicast, when
                               enabled.";
                          }
                        }
                        container pbb {
                          when "derived-from-or-self("
                             + "../../evpn-type, 'pbb-evpn')" {
                            description
                              "Only applies for PBB EVPN.";
                          }
                          description
                            "PBB parameters container.";
                          reference
                            "IEEE 802.1ah: Provider Backbone
                                           Bridges";
                          leaf backbone-src-mac {
                            type yang:mac-address;
                            description
                              "Includes Provider Backbone MAC (B-MAC)
                               address.";
                            reference
                              "RFC 7623: Provider Backbone Bridging
                                         Combined with Ethernet VPN
                                         (PBB-EVPN), Section 8.1";
                          }
                        }
                      }
                    }
                  }
                }
                container ldp-or-l2tp {
                  description
                    "Container for LDP or L2TP-signaled PWs
                     choice.";
                  leaf agi {
                    type rt-types:route-distinguisher;
                    description
                      "Attachment Group Identifier.  Also, called
                       VPLS-Id.";
                    reference
                      "RFC 4667: Layer 2 Virtual Private Network
                                 (L2VPN) Extensions for Layer 2
                                 Tunneling Protocol (L2TP),
                                 Section 4.3
                       RFC 4762: Virtual Private LAN Service (VPLS)
                                 Using Label Distribution Protocol
                                 (LDP) Signaling, Section 6.1.1";
                  }
                  leaf saii {
                    type uint32;
                    description
                      "Source Attachment Individual Identifier
                       (SAII).";
                    reference
                      "RFC 4667: Layer 2 Virtual Private Network
                                 (L2VPN) Extensions for Layer 2
                                 Tunneling Protocol (L2TP),
                                 Section 3";
                  }
                  list remote-targets {
                    key "taii";
                    description
                      "List of allowed target Attachment Individual
                       Identifiers (AIIs) and peers.";
                    reference
                      "RFC 4667: Layer 2 Virtual Private Network
                                 (L2VPN) Extensions for Layer 2
                                 Tunneling Protocol (L2TP),
                                 Section 5";
                    leaf taii {
                      type uint32;
                      description
                        "Target Attachment Individual Identifier.";
                      reference
                        "RFC 4667: Layer 2 Virtual Private Network
                                   (L2VPN) Extensions for Layer 2
                                   Tunneling  Protocol (L2TP),
                                   Section 3";
                    }
                    leaf peer-addr {
                      type inet:ip-address;
                      description
                        "Indicates the peer forwarder's IP address.";
                    }
                  }
                  choice ldp-or-l2tp {
                    description
                      "Choice of LDP or L2TP-signaled PWs.";
                    case ldp {
                      description
                        "Container for T-LDP PW configurations.";
                      leaf t-ldp-pw-type {
                        type identityref {
                          base t-ldp-pw-type;
                        }
                        description
                          "T-LDP PW type.";
                      }
                      leaf pw-type {
                        type identityref {
                          base ldp-pw-type;
                        }
                        description
                          "PW encapsulation type.";
                        reference
                          "RFC 4762: Virtual Private LAN Service
                                     (VPLS) Using Label Distribution
                                     Protocol (LDP) Signaling,
                                     Section 6.1.1";
                      }
                      leaf pw-description {
                        type string;
                        description
                          "Includes a human-readable description
                           of the interface.  This may be used when
                           communicating with a remote peer.";
                        reference
                          "RFC 4762: Virtual Private LAN Service
                                     (VPLS) Using Label Distribution
                                     Protocol (LDP) Signaling,
                                     Section 6.1.1";
                      }
                      leaf mac-addr-withdraw {
                        type boolean;
                        description
                          "If set to 'true', then MAC address
                           withdrawal is enabled.  If 'false',
                           then MAC address withdrawal is
                           disabled.";
                        reference
                          "RFC 4762: Virtual Private LAN Service
                                     (VPLS) Using Label Distribution
                                     Protocol (LDP) Signaling,
                                     Section 6.2";
                      }
                      list pw-peer-list {
                        key "peer-addr vc-id";
                        description
                          "List of attachment circuit (AC) and PW
                           bindings.";
                        leaf peer-addr {
                          type inet:ip-address;
                          description
                            "Indicates the peer's IP address.";
                        }
                        leaf vc-id {
                          type string;
                          description
                            "VC label used to identify a PW.";
                        }
                        leaf pw-priority {
                          type uint32;
                          description
                            "Defines the priority for the PW.
                             The higher the pw-priority value, the
                             higher the preference of the PW will
                             be.";
                        }
                      }
                      container qinq {
                        when "derived-from-or-self("
                           + "../t-ldp-pw-type, 'hvpls')" {
                          description
                            "Only applies when T-LDP PW type
                             is H-VPLS.";
                        }
                        description
                          "Container for QinQ.";
                        leaf s-tag {
                          type dot1q-types:vlanid;
                          mandatory true;
                          description
                            "S-TAG.";
                        }
                        leaf c-tag {
                          type dot1q-types:vlanid;
                          mandatory true;
                          description
                            "C-TAG.";
                        }
                      }
                    }
                    case l2tp {
                      description
                        "Container for L2TP PWs.";
                      leaf router-id {
                        type rt-types:router-id;
                        description
                          "A 32-bit number in the dotted-quad format
                           that is used to uniquely identify a node
                           within a service provider network.";
                        reference
                          "RFC 4667: Layer 2 Virtual Private Network
                                     (L2VPN) Extensions for Layer 2
                                     Tunneling Protocol (L2TP),
                                     Section 4.2";
                      }
                      leaf pseudowire-type {
                        type identityref {
                          base iana-pw-types:iana-pw-types;
                        }
                        description
                          "Encapsulation type.";
                        reference
                          "RFC 4667: Layer 2 Virtual Private Network
                                     (L2VPN) Extensions for Layer 2
                                     Tunneling Protocol (L2TP),
                                     Section 4.2";
                      }
                    }
                  }
                }
              }
            }
            container vpn-network-accesses {
              description
                "Main container for VPN network accesses.";
              list vpn-network-access {
                key "id";
                description
                  "List of VPN network accesses.";
                leaf id {
                  type vpn-common:vpn-id;
                  description
                    "Identifier of the network access.";
                }
                leaf description {
                  type string;
                  description
                    "A textual description of the VPN network
                     access.";
                }
                leaf interface-id {
                  type string;
                  description
                    "Refers to a physical or logical interface.";
                }
                leaf active-vpn-node-profile {
                  type leafref {
                    path "../../.."
                       + "/active-global-parameters-profiles"
                       + "/global-parameters-profile/profile-id";
                  }
                  description
                    "An identifier of an active VPN instance
                     profile.";
                }
                uses vpn-common:service-status;
                container connection {
                  description
                    "Container for the bearer and AC.";
                  leaf l2-termination-point {
                    type string;
                    description
                      "Specifies a reference to a local Layer 2
                       termination point such as a Layer 2
                       sub-interface.";
                  }
                  leaf local-bridge-reference {
                    type string;
                    description
                      "Specifies a local bridge reference to
                       accommodate, for example, implementations
                       that require internal bridging.
                       A reference may be a local bridge domain.";
                  }
                  leaf bearer-reference {
                    if-feature "vpn-common:bearer-reference";
                    type string;
                    description
                      "This is an internal reference for the service
                       provider to identify the bearer associated
                       with this VPN.";
                  }
                  container encapsulation {
                    description
                      "Container for Layer 2 encapsulation.";
                    leaf encap-type {
                      type identityref {
                        base vpn-common:encapsulation-type;
                      }
                      default "vpn-common:priority-tagged";
                      description
                        "Tagged interface type.  By default, the
                         type of the tagged interface is
                         'priority-tagged'.";
                    }
                    container dot1q {
                      when "derived-from-or-self(../encap-type, "
                         + "'vpn-common:dot1q')" {
                        description
                          "Only applies when the type of the
                           tagged interface is 'dot1q'.";
                      }
                      description
                        "Tagged interface.";
                      leaf tag-type {
                        type identityref {
                          base vpn-common:tag-type;
                        }
                        default "vpn-common:c-vlan";
                        description
                          "Tag type.  By default, the tag type is
                           'c-vlan'.";
                      }
                      leaf cvlan-id {
                        type dot1q-types:vlanid;
                        description
                          "VLAN identifier.";
                      }
                      container tag-operations {
                        description
                          "Sets the tag manipulation policy for this
                           VPN network access.  It defines a set of
                           tag manipulations that allow for the
                           insertion, removal, or rewriting
                           of 802.1Q VLAN tags.  These operations are
                           indicated for the CE-PE direction.
                           By default, tag operations are symmetric.
                           As such, the reverse tag operation is
                           assumed on the PE-CE direction.";
                        choice op-choice {
                          description
                            "Selects the tag rewriting policy for a
                             VPN network access.";
                          leaf pop {
                            type empty;
                            description
                              "Pop the outer tag.";
                          }
                          leaf push {
                            type empty;
                            description
                              "Pushes one or two tags defined by the
                               tag-1 and tag-2 leaves.  It is
                               assumed that, absent any policy, the
                               default value of 0 will be used for
                               the PCP setting.";
                          }
                          leaf translate {
                            type empty;
                            description
                              "Translates the outer tag to one or two
                               tags.  PCP bits are preserved.";
                          }
                        }
                        leaf tag-1 {
                          when 'not(../pop)';
                          type dot1q-types:vlanid;
                          description
                            "A first tag to be used for push or
                             translate operations.  This tag will be
                             used as the outermost tag as a result
                             of the tag operation.";
                        }
                        leaf tag-1-type {
                          type dot1q-types:dot1q-tag-type;
                          default "dot1q-types:s-vlan";
                          description
                            "Specifies a specific 802.1Q tag type
                             of tag-1.";
                        }
                        leaf tag-2 {
                          when '(../translate)';
                          type dot1q-types:vlanid;
                          description
                            "A second tag to be used for
                             translation.";
                        }
                        leaf tag-2-type {
                          type dot1q-types:dot1q-tag-type;
                          default "dot1q-types:c-vlan";
                          description
                            "Specifies a specific 802.1Q tag type
                             of tag-2.";
                        }
                      }
                    }
                    container priority-tagged {
                      when "derived-from-or-self(../encap-type, "
                         + "'vpn-common:priority-tagged')" {
                        description
                          "Only applies when the type of the
                           tagged interface is 'priority-tagged'.";
                      }
                      description
                        "Priority tagged container.";
                      leaf tag-type {
                        type identityref {
                          base vpn-common:tag-type;
                        }
                        default "vpn-common:c-vlan";
                        description
                          "Tag type.  By default, the tag type is
                           'c-vlan'.";
                      }
                    }
                    container qinq {
                      when "derived-from-or-self(../encap-type, "
                         + "'vpn-common:qinq')" {
                        description
                          "Only applies when the type of the tagged
                           interface is 'QinQ'.";
                      }
                      description
                        "Includes QinQ parameters.";
                      leaf tag-type {
                        type identityref {
                          base vpn-common:tag-type;
                        }
                        default "vpn-common:s-c-vlan";
                        description
                          "Tag type.  By default, the tag type is
                           's-c-vlan'.";
                      }
                      leaf svlan-id {
                        type dot1q-types:vlanid;
                        mandatory true;
                        description
                          "S-VLAN identifier.";
                      }
                      leaf cvlan-id {
                        type dot1q-types:vlanid;
                        mandatory true;
                        description
                          "C-VLAN identifier.";
                      }
                      container tag-operations {
                        description
                          "Sets the tag manipulation policy for this
                           VPN network access.  It defines a set of
                           tag manipulations that allow for the
                           insertion, removal, or rewriting
                           of 802.1Q VLAN tags.  These operations are
                           indicated for the CE-PE direction.
                           By default, tag operations are symmetric.
                           As such, the reverse tag operation is
                           assumed on the PE-CE direction.";
                        choice op-choice {
                          description
                            "Selects the tag rewriting policy for a
                             VPN network access.";
                          leaf pop {
                            type uint8 {
                              range "1|2";
                            }
                            description
                              "Pops one or two tags as a function
                               of the indicated pop value.";
                          }
                          leaf push {
                            type empty;
                            description
                              "Pushes one or two tags defined by the
                               tag-1 and tag-2 leaves.  It is
                               assumed that, absent any policy, the
                               default value of 0 will be used for
                               PCP setting.";
                          }
                          leaf translate {
                            type uint8 {
                              range "1|2";
                            }
                            description
                              "Translates one or two outer tags.  PCP
                               bits are preserved.

                               The following operations are
                               supported:

                               - translate 1 with tag-1 leaf is
                                 provided: only the outermost tag is
                                 translated to the value in tag-1.

                               - translate 2 with both tag-1 and
                                 tag-2 leaves are provided: both
                                 outer and inner tags are translated
                                 to the values in tag-1 and tag-2,
                                 respectively.

                               - translate 2 with tag-1 leaf is
                                 provided: the outer tag is popped
                                 while the inner tag is translated
                                 to the value in tag-1.";
                          }
                        }
                        leaf tag-1 {
                          when 'not(../pop)';
                          type dot1q-types:vlanid;
                          description
                            "A first tag to be used for push or
                             translate operations.  This tag will be
                             used as the outermost tag as a result
                             of the tag operation.";
                        }
                        leaf tag-1-type {
                          type dot1q-types:dot1q-tag-type;
                          default "dot1q-types:s-vlan";
                          description
                            "Specifies a specific 802.1Q tag type
                             of tag-1.";
                        }
                        leaf tag-2 {
                          when 'not(../pop)';
                          type dot1q-types:vlanid;
                          description
                            "A second tag to be used for push or
                             translate operations.";
                        }
                        leaf tag-2-type {
                          type dot1q-types:dot1q-tag-type;
                          default "dot1q-types:c-vlan";
                          description
                            "Specifies a specific 802.1Q tag type
                             of tag-2.";
                        }
                      }
                    }
                  }
                  container lag-interface {
                    if-feature "vpn-common:lag-interface";
                    description
                      "Container of LAG interface attributes
                       configuration.";
                    leaf lag-interface-id {
                      type string;
                      description
                        "LAG interface identifier.";
                    }
                    container lacp {
                      description
                        "Container for LACP.";
                      leaf lacp-state {
                        type boolean;
                        default "false";
                        description
                          "Controls whether LACP is enabled.";
                      }
                      leaf mode {
                        type identityref {
                          base lacp-mode;
                        }
                        description
                          "Indicates the LACP mode.";
                      }
                      leaf speed {
                        type uint32;
                        units "mbps";
                        default "10";
                        description
                          "LACP speed.  This low default value
                           is inherited from the L2SM.";
                      }
                      leaf mini-link-num {
                        type uint32;
                        description
                          "Defines the minimum number of links that
                           must be active before the aggregating
                           link is put into service.";
                      }
                      leaf system-id {
                        type yang:mac-address;
                        description
                          "Indicates the System ID used by LACP.";
                      }
                      leaf admin-key {
                        type uint16;
                        description
                          "Indicates the value of the key used for
                           the aggregate interface.";
                      }
                      leaf system-priority {
                        type uint16 {
                          range "0..65535";
                        }
                        default "32768";
                        description
                          "Indicates the LACP priority for the
                           system.";
                      }
                      container member-link-list {
                        description
                          "Container of Member link list.";
                        list member-link {
                          key "name";
                          description
                            "Member link.";
                          leaf name {
                            type string;
                            description
                              "Member link name.";
                          }
                          leaf speed {
                            type uint32;
                            units "mbps";
                            default "10";
                            description
                              "Port speed.";
                          }
                          leaf mode {
                            type identityref {
                              base vpn-common:neg-mode;
                            }
                            description
                              "Negotiation mode.";
                          }
                          leaf link-mtu {
                            type uint32;
                            units "bytes";
                            description
                              "Link MTU size.";
                          }
                          container oam-802.3ah-link {
                            if-feature "oam-3ah";
                            description
                              "Container for the OAM 802.3ah
                               link.";
                            leaf enable {
                              type boolean;
                              default "false";
                              description
                                "Indicates support of the OAM
                                 802.3ah link.";
                            }
                          }
                        }
                      }
                      leaf flow-control {
                        type boolean;
                        default "false";
                        description
                          "Indicates whether flow control is
                           supported.";
                      }
                      leaf lldp {
                        type boolean;
                        default "false";
                        description
                          "Indicates whether the Link Layer
                           Discovery Protocol (LLDP) is
                           supported.";
                      }
                    }
                    container split-horizon {
                      description
                        "Configuration with Split Horizon enabled.";
                      leaf group-name {
                        type string;
                        description
                          "Group name of the Split Horizon.";
                      }
                    }
                  }
                }
                choice signaling-option {
                  description
                    "Choice for the signaling-option.";
                  case bgp {
                    description
                      "BGP is used as the signaling protocol.";
                    choice bgp-type {
                      description
                        "Choice for the BGP type.";
                      case l2vpn-bgp {
                        description
                          "Container for BGP L2VPN.";
                        leaf ce-id {
                          type uint16;
                          description
                            "Identifies the CE within the VPN.";
                          reference
                            "RFC 6624: Layer 2 Virtual Private
                                       Networks Using BGP for
                                       Auto-Discovery and
                                       Signaling";
                        }
                        leaf remote-ce-id {
                          type uint16;
                          description
                            "Indicates the identifier of the remote
                             CE.";
                        }
                        container vpls-instance {
                          when "derived-from-or-self(../../../../../"
                             + "vpn-type, 'vpn-common:vpls')" {
                            description
                              "Only applies for VPLS.";
                          }
                          description
                            "VPLS instance.";
                          leaf vpls-edge-id {
                            type uint16;
                            description
                              "VPLS Edge Identifier (VE ID).";
                            reference
                              "RFC 4761: Virtual Private LAN Service
                                         (VPLS) Using BGP for Auto-
                                         Discovery and Signaling,
                                         Section 3.2.1";
                          }
                        }
                      }
                      case evpn-bgp {
                        description
                          "Used for EVPN.";
                        leaf df-preference {
                          type uint16;
                          default "32767";
                          description
                            "Defines a 2-octet value that indicates
                             the PE preference to become the DF in
                             the ES.

                             The preference value is only applicable
                             to the preference-based method.";
                          reference
                            "RFC 8584: Framework for Ethernet VPN
                                       Designated Forwarder Election
                                       Extensibility";
                        }
                        container vpws-service-instance {
                          when "derived-from-or-self(../../../../../"
                             + "vpn-type, 'vpn-common:vpws-evpn')" {
                            description
                              "Only applies for EVPN-VPWS.";
                          }
                          description
                            "Local and remote VPWS Service Instance
                             (VSI)";
                          reference
                            "RFC 8214: Virtual Private Wire Service
                                       Support in Ethernet VPN";
                          choice local-vsi-choice {
                            description
                              "Choices for assigning local VSI.";
                            case directly-assigned {
                              description
                                "Explicitly assign a local VSI.";
                              leaf local-vpws-service-instance {
                                type uint32 {
                                  range "1..16777215";
                                }
                                description
                                  "Indicates the assigned local
                                   VSI.";
                              }
                            }
                            case auto-assigned {
                              description
                                "The local VSI is auto-assigned.";
                              container local-vsi-auto {
                                description
                                  "The local VSI is auto-assigned.";
                                choice auto-mode {
                                  description
                                    "Indicates the auto-assignment
                                     mode of local VSI.  VSI can be
                                     automatically assigned either
                                     with or without indicating a
                                     pool from which the VSI
                                     should be taken.

                                     For both cases, the server
                                     will auto-assign a local VSI
                                     value and use that value.";
                                  case from-pool {
                                    leaf vsi-pool-name {
                                      type string;
                                      description
                                        "The auto-assignment will be
                                         made from this pool.";
                                    }
                                  }
                                  case full-auto {
                                    leaf auto {
                                      type empty;
                                      description
                                        "Indicates that a local VSI
                                         is fully auto-assigned.";
                                    }
                                  }
                                }
                                leaf auto-local-vsi {
                                  type uint32 {
                                    range "1..16777215";
                                  }
                                  config false;
                                  description
                                    "The value of the auto-assigned
                                     local VSI.";
                                }
                              }
                            }
                          }
                          choice remote-vsi-choice {
                            description
                              "Choice for assigning the remote VSI.";
                            case directly-assigned {
                              description
                                "Explicitly assign a remote VSI.";
                              leaf remote-vpws-service-instance {
                                type uint32 {
                                  range "1..16777215";
                                }
                                description
                                  "Indicates the value of the remote
                                   VSI.";
                              }
                            }
                            case auto-assigned {
                              description
                                "The remote VSI is auto-assigned.";
                              container remote-vsi-auto {
                                description
                                  "The remote VSI is auto-assigned.";
                                choice auto-mode {
                                  description
                                    "Indicates the auto-assignment
                                     mode of remote VSI.  VSI can be
                                     automatically assigned either
                                     with or without indicating a
                                     pool from which the VSI
                                     should be taken.

                                     For both cases, the server
                                     will auto-assign a remote VSI
                                     value and use that value.";
                                  case from-pool {
                                    leaf vsi-pool-name {
                                      type string;
                                      description
                                        "The auto-assignment will be
                                         made from this pool.";
                                    }
                                  }
                                  case full-auto {
                                    leaf auto {
                                      type empty;
                                      description
                                        "Indicates that a remote VSI
                                         is fully auto-assigned.";
                                    }
                                  }
                                }
                                leaf auto-remote-vsi {
                                  type uint32 {
                                    range "1..16777215";
                                  }
                                  config false;
                                  description
                                    "The value of the auto-assigned
                                     remote VSI.";
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
                list group {
                  key "group-id";
                  description
                    "List of group-ids.";
                  leaf group-id {
                    type string;
                    description
                      "Indicates the group-id to which the network
                       access belongs to.";
                  }
                  leaf precedence {
                    type identityref {
                      base precedence-type;
                    }
                    description
                      "Defines service redundancy in transport
                       network.";
                  }
                  leaf ethernet-segment-identifier {
                    type l2vpn-es:es-ref;
                    description
                      "Reference to the ESI associated with the VPN
                       network access.";
                  }
                }
                container ethernet-service-oam {
                  description
                    "Container for Ethernet service OAM.";
                  leaf md-name {
                    type string;
                    description
                      "Maintenance domain name.";
                  }
                  leaf md-level {
                    type uint8;
                    description
                      "Maintenance domain level.";
                  }
                  container cfm-802.1-ag {
                    description
                      "Container of 802.1ag CFM configurations.";
                    list n2-uni-c {
                      key "maid";
                      description
                        "List of UNI-N to UNI-C.";
                      uses cfm-802;
                    }
                    list n2-uni-n {
                      key "maid";
                      description
                        "List of UNI-N to UNI-N.";
                      uses cfm-802;
                    }
                  }
                  uses y-1731;
                }
                container service {
                  description
                    "Container for service";
                  leaf mtu {
                    type uint32;
                    units "bytes";
                    description
                      "Layer 2 MTU; it is also known as the maximum
                       transmission unit or maximum frame size.";
                  }
                  container svc-pe-to-ce-bandwidth {
                    if-feature "vpn-common:inbound-bw";
                    description
                      "From the customer site's perspective, the
                       service inbound bandwidth of the connection
                       or download bandwidth from the service
                       provider to the site.  Note that the L2SM uses
                       'input-bandwidth' to refer to the same
                       concept.";
                    list pe-to-ce-bandwidth {
                      key "bw-type";
                      description
                        "List for PE-to-CE bandwidth data nodes.";
                      leaf bw-type {
                        type identityref {
                          base vpn-common:bw-type;
                        }
                        description
                          "Indicates the bandwidth type.";
                      }
                      choice type {
                        description
                          "Choice based upon bandwidth type.";
                        case per-cos {
                          description
                            "Bandwidth per CoS.";
                          list cos {
                            key "cos-id";
                            description
                              "List of Class of Services.";
                            leaf cos-id {
                              type uint8;
                              description
                                "Identifier of the CoS, indicated by
                                 a Differentiated Services Code Point
                                 (DSCP) or a CE-CLAN CoS (802.1p)
                                 value in the service frame.";
                              reference
                                "IEEE Std 802.1Q: Bridges and Bridged
                                                  Networks";
                            }
                            uses bandwidth-parameters;
                          }
                        }
                        case other {
                          description
                            "Other bandwidth types.";
                          uses bandwidth-parameters;
                        }
                      }
                    }
                  }
                  container svc-ce-to-pe-bandwidth {
                    if-feature "vpn-common:outbound-bw";
                    description
                      "From the customer site's perspective,
                       the service outbound bandwidth of the
                       connection or upload bandwidth from
                       the CE to the PE.  Note that the L2SM uses
                       'output-bandwidth' to refer to the same
                       concept.";
                    list ce-to-pe-bandwidth {
                      key "bw-type";
                      description
                        "List for CE-to-PE bandwidth.";
                      leaf bw-type {
                        type identityref {
                          base vpn-common:bw-type;
                        }
                        description
                          "Indicates the bandwidth type.";
                      }
                      choice type {
                        description
                          "Choice based upon bandwidth type.";
                        case per-cos {
                          description
                            "Bandwidth per CoS.";
                          list cos {
                            key "cos-id";
                            description
                              "List of Class of Services.";
                            leaf cos-id {
                              type uint8;
                              description
                                "Identifier of the CoS, indicated by
                                 DSCP or a CE-CLAN CoS (802.1p) value
                                 in the service frame.";
                              reference
                                "IEEE Std 802.1Q: Bridges and Bridged
                                                  Networks";
                            }
                            uses bandwidth-parameters;
                          }
                        }
                        case other {
                          description
                            "Other non CoS-aware bandwidth types.";
                          uses bandwidth-parameters;
                        }
                      }
                    }
                  }
                  container qos {
                    if-feature "vpn-common:qos";
                    description
                      "QoS configuration.";
                    container qos-classification-policy {
                      description
                        "Configuration of the traffic classification
                         policy.";
                      list rule {
                        key "id";
                        ordered-by user;
                        description
                          "List of classification rules.";
                        leaf id {
                          type string;
                          description
                            "A description identifying the QoS
                             classification policy rule.";
                        }
                        choice match-type {
                          default "match-flow";
                          description
                            "Choice for classification.";
                          case match-flow {
                            container match-flow {
                              description
                                "Describes flow-matching criteria.";
                              leaf dscp {
                                type inet:dscp;
                                description
                                  "DSCP value.";
                              }
                              leaf dot1q {
                                type uint16;
                                description
                                  "802.1Q matching. It is a VLAN tag
                                   added into a frame.";
                                reference
                                  "IEEE Std 802.1Q: Bridges and
                                                    Bridged
                                                    Networks";
                              }
                              leaf pcp {
                                type uint8 {
                                  range "0..7";
                                }
                                description
                                  "Priority Code Point (PCP) value.";
                              }
                              leaf src-mac-address {
                                type yang:mac-address;
                                description
                                  "Source MAC address.";
                              }
                              leaf dst-mac-address {
                                type yang:mac-address;
                                description
                                  "Destination MAC address.";
                              }
                              leaf color-type {
                                type identityref {
                                  base color-type;
                                }
                                description
                                  "Color type.";
                              }
                              leaf any {
                                type empty;
                                description
                                  "Allows all.";
                              }
                            }
                          }
                          case match-application {
                            leaf match-application {
                              type identityref {
                                base vpn-common:customer-application;
                              }
                              description
                                "Defines the application to match.";
                            }
                          }
                        }
                        leaf target-class-id {
                          type string;
                          description
                            "Identification of the CoS.
                             This identifier is internal to the
                             administration.";
                        }
                      }
                    }
                    container qos-profile {
                      description
                        "QoS profile configuration.";
                      list qos-profile {
                        key "profile";
                        description
                          "QoS profile.
                           Can be a standard or customized
                           profile.";
                        leaf profile {
                          type leafref {
                            path "/l2vpn-ntw/vpn-profiles"
                               + "/valid-provider-identifiers"
                               + "/qos-profile-identifier/id";
                          }
                          description
                            "QoS profile to be used.";
                        }
                        leaf direction {
                          type identityref {
                            base vpn-common:qos-profile-direction;
                          }
                          default "vpn-common:both";
                          description
                            "The direction to which the QoS profile
                             is applied.";
                        }
                      }
                    }
                  }
                  container mac-policies {
                    description
                      "Container for MAC-related policies.";
                    list access-control-list {
                      key "name";
                      description
                        "Container for the Access Control List
                         (ACL).";
                      leaf name {
                        type string;
                        description
                          "Specifies the name of the ACL.";
                      }
                      leaf-list src-mac-address {
                        type yang:mac-address;
                        description
                          "Specifies the source MAC address.";
                      }
                      leaf-list src-mac-address-mask {
                        type yang:mac-address;
                        description
                          "Specifies the source MAC address mask.";
                      }
                      leaf-list dst-mac-address {
                        type yang:mac-address;
                        description
                          "Specifies the destination MAC address.";
                      }
                      leaf-list dst-mac-address-mask {
                        type yang:mac-address;
                        description
                          "Specifies the destination MAC address
                           mask.";
                      }
                      leaf action {
                        type identityref {
                          base mac-action;
                        }
                        default "drop";
                        description
                          "Specifies the filtering action.";
                      }
                      leaf rate-limit {
                        when "derived-from-or-self(../action, "
                           + "'flood')" {
                          description
                            "Rate-limit is valid only when the action
                             is to accept the matching frame.";
                        }
                        type decimal64 {
                          fraction-digits 2;
                        }
                        units "bytes per second";
                        description
                          "Specifies how to rate-limit the traffic.";
                      }
                    }
                    container mac-loop-prevention {
                      description
                        "Container of MAC loop prevention.";
                      leaf window {
                        type uint32;
                        units "seconds";
                        default "180";
                        description
                          "The timer when a MAC mobility event is
                           detected.";
                      }
                      leaf frequency {
                        type uint32;
                        default "5";
                        description
                          "The number of times to detect MAC
                           duplication, where a 'duplicate MAC
                           address' situation has occurred and
                           the duplicate MAC address has been
                           added to a list of duplicate MAC
                           addresses.";
                      }
                      leaf retry-timer {
                        type uint32;
                        units "seconds";
                        description
                          "The retry timer.  When the retry timer
                           expires, the duplicate MAC address will
                           be flushed from the MAC-VRF.";
                      }
                      leaf protection-type {
                        type identityref {
                          base loop-prevention-type;
                        }
                        default "trap";
                        description
                          "Protection type";
                      }
                    }
                    container mac-addr-limit {
                      description
                        "Container of MAC-Addr limit
                         configurations.";
                      leaf limit-number {
                        type uint16;
                        default "2";
                        description
                          "Maximum number of MAC addresses learned
                           from the subscriber for a single service
                           instance.";
                      }
                      leaf time-interval {
                        type uint32;
                        units "milliseconds";
                        default "300";
                        description
                          "The aging time of the MAC address.";
                      }
                      leaf action {
                        type identityref {
                          base mac-action;
                        }
                        default "warning";
                        description
                          "Specifies the action when the upper limit
                           is exceeded: drop the packet, flood the
                           packet, or log a warning message (without
                           dropping the packet).";
                      }
                    }
                  }
                  container broadcast-unknown-unicast-multicast {
                    description
                      "Container of broadcast, unknown unicast, or
                       multicast configurations.";
                    leaf multicast-site-type {
                      type enumeration {
                        enum receiver-only {
                          description
                            "The site only has receivers.";
                        }
                        enum source-only {
                          description
                            "The site only has sources.";
                        }
                        enum source-receiver {
                          description
                            "The site has both sources and
                             receivers.";
                        }
                      }
                      default "source-receiver";
                      description
                        "Type of the multicast site.";
                    }
                    list multicast-gp-address-mapping {
                      key "id";
                      description
                        "List of port-to-group mappings.";
                      leaf id {
                        type uint16;
                        description
                          "Unique identifier for the mapping.";
                      }
                      leaf vlan-id {
                        type uint32;
                        mandatory true;
                        description
                          "The VLAN ID of the multicast group.";
                      }
                      leaf mac-gp-address {
                        type yang:mac-address;
                        mandatory true;
                        description
                          "The MAC address of the multicast group.";
                      }
                      leaf port-lag-number {
                        type uint32;
                        description
                          "The port/LAG belonging to the multicast
                           group.";
                      }
                    }
                    leaf bum-overall-rate {
                      type uint64;
                      units "bps";
                      description
                        "Overall rate for BUM.";
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

 
                   
                   +-----+   +--------------+   +-----+    
      +----+       | PE1 |===|              |===| PE3 |       +----+
      | CE1+-------+     |   |              |   |     +-------+ CE3|
      +----+       +-----+   |              |   +-----+       +----+
                             |     Core     |                 
      +----+       +-----+   |              |   +-----+       +----+
      |CE2 +-------+     |   |              |   |     +-------+ CE4|
      +----+       | PE2 |===|              |===| PE4 |       +----+
                   +-----+   +--------------+   +-----+          
 

=============== NOTE: '\' line wrapping per RFC 8792 ================

{
  "ietf-l2vpn-ntw:l2vpn-ntw": {
    "vpn-services": {
      "vpn-service": [
        {
          "vpn-id": "vpls7714825356",
          "vpn-description": "Sample BGP-based VPLS",
          "customer-name": "customer-7714825356",
          "vpn-type": "ietf-vpn-common:vpls",
          "bgp-ad-enabled": true,
          "signaling-type": "ietf-vpn-common:bgp-signaling",
          "global-parameters-profiles": {
            "global-parameters-profile": [
              {
                "profile-id": "simple-profile",
                "local-autonomous-system": 65535,
                "svc-mtu": 1518,
                "rd-suffix": 1,
                "vpn-target": [
                  {
                    "id": 1,
                    "route-targets": [
                      {
                        "route-target": "0:65535:1"
                      }
                    ],
                    "route-target-type": "both"
                  }
                ]
              }
            ]
          },
          "vpn-nodes": {
            "vpn-node": [
              {
                "vpn-node-id": "pe1",
                "ne-id": "198.51.100.1",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "bgp-auto-discovery": {
                  "vpn-id": "1"
                },
                "signaling-option": {
                  "pw-encapsulation-type": "iana-bgp-l2-encaps:\
                   ethernet-tagged-mode",
                  "vpls-instance": {
                    "vpls-edge-id": 1,
                    "vpls-edge-id-range": 100
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE1",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      }
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe2",
                "ne-id": "198.51.100.2",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "bgp-auto-discovery": {
                  "vpn-id": "1"
                },
                "signaling-option": {
                  "pw-encapsulation-type": "iana-bgp-l2-encaps:\
                   ethernet-tagged-mode",
                  "vpls-instance": {
                    "vpls-edge-id": 2,
                    "vpls-edge-id-range": 100
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE2",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      }
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe3",
                "ne-id": "198.51.100.3",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "bgp-auto-discovery": {
                  "vpn-id": "1"
                },
                "signaling-option": {
                  "pw-encapsulation-type": "iana-bgp-l2-encaps:\
                   ethernet-tagged-mode",
                  "vpls-instance": {
                    "vpls-edge-id": 3,
                    "vpls-edge-id-range": 100
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE3",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      }
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe4",
                "ne-id": "198.51.100.4",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "bgp-auto-discovery": {
                  "vpn-id": "1"
                },
                "signaling-option": {
                  "pw-encapsulation-type": "iana-bgp-l2-encaps:\
                   ethernet-tagged-mode",
                  "vpls-instance": {
                    "vpls-edge-id": 4,
                    "vpls-edge-id-range": 100
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE4",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}

                   
                   +-----+   +--------------+   +-----+    
      +----+       | PE1 |===|              |===| PE2 |       +----+
      | CE1+-------+     |   |     Core     |   |     +-------+ CE2|
      +----+       +-----+   +--------------+   +-----+       +----+
             site1                                      site2 

{
  "ietf-l2vpn-ntw:l2vpn-ntw": {
    "vpn-services": {
      "vpn-service": [
        {
          "vpn-id": "vpws12345",
          "vpn-description": "Sample VPWS",
          "customer-name": "customer-12345",
          "vpn-type": "ietf-vpn-common:vpws",
          "bgp-ad-enabled": true,
          "signaling-type": "ietf-vpn-common:ldp-signaling",
          "global-parameters-profiles": {
            "global-parameters-profile": [
              {
                "profile-id": "simple-profile",
                "local-autonomous-system": 65550,
                "rd-auto": {
                  "auto": [
                    null
                  ]
                },
                "vpn-target": [
                  {
                    "id": 1,
                    "route-targets": [
                      {
                        "route-target": "0:65535:1"
                      }
                    ],
                    "route-target-type": "both"
                  }
                ]
              }
            ]
          },
          "vpn-nodes": {
            "vpn-node": [
              {
                "vpn-node-id": "pe1",
                "ne-id": "2001:db8:100::1",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "bgp-auto-discovery": {
                  "vpn-id": "587"
                },
                "signaling-option": {
                  "advertise-mtu": true,
                  "ldp-or-l2tp": {
                    "saii": 1,
                    "remote-targets": [
                      {
                        "taii": 2
                      }
                    ],
                    "t-ldp-pw-type": "ethernet"
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE1",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      }
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe2",
                "ne-id": "2001:db8:200::1",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "bgp-auto-discovery": {
                  "vpn-id": "587"
                },
                "signaling-option": {
                  "advertise-mtu": true,
                  "ldp-or-l2tp": {
                    "saii": 2,
                    "remote-targets": [
                      {
                        "taii": 1
                      }
                    ],
                    "t-ldp-pw-type": "ethernet"
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "5/1/1.1",
                      "interface-id": "5/1/1",
                      "description": "Interface to CE2",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}

                
                  +----------  VPLS "1543" ----------+
                                                           
                  +-----+   +--------------+   +-----+    
      +----+      | PE1 |===|              |===| PE2 |       +----+
      | CE1 +-----+"450"|   |     MPLS     |   |"451"+-------+ CE2|
      +----+      +-----+   |              |   +-----+       +----+
                            |     Core     |                 
                            +--------------+           
        

=============== NOTE: '\' line wrapping per RFC 8792 ================

{
  "ietf-l2vpn-ntw:l2vpn-ntw": {
    "vpn-services": {
      "vpn-service": [
        {
          "vpn-id": "450",
          "vpn-name": "CORPO-EXAMPLE",
          "vpn-description": "SEDE_CENTRO_450",
          "customer-name": "EXAMPLE",
          "vpn-type": "ietf-vpn-common:vpls",
          "vpn-service-topology": "ietf-vpn-common:hub-spoke",
          "bgp-ad-enabled": false,
          "signaling-type": "ietf-vpn-common:ldp-signaling",
          "global-parameters-profiles": {
            "global-parameters-profile": [
              {
                "profile-id": "simple-profile",
                "ce-vlan-preservation": true,
                "ce-vlan-cos-preservation": true
              }
            ]
          },
          "vpn-nodes": {
            "vpn-node": [
              {
                "vpn-node-id": "450",
                "description": "SEDE_CENTRO_450",
                "ne-id": "2001:db8:5::1",
                "role": "ietf-vpn-common:hub-role",
                "status": {
                  "admin-status": {
                    "status": "ietf-vpn-common:admin-up"
                  }
                },
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "signaling-option": {
                  "ldp-or-l2tp": {
                    "t-ldp-pw-type": "vpls-type",
                    "pw-peer-list": [
                      {
                        "peer-addr": "2001:db8:50::1",
                        "vc-id": "1543"
                      }
                    ]
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "4508671287",
                      "description": "VPN_450_SNA",
                      "interface-id": "gigabithethernet0/0/1",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "l2-termination-point": "550",
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "tag-type": "ietf-vpn-common:c-vlan",
                            "cvlan-id": 550
                          }
                        }
                      },
                      "service": {
                        "mtu": 1550,
                        "svc-pe-to-ce-bandwidth": {
                          "pe-to-ce-bandwidth": [
                            {
                              "bw-type": "ietf-vpn-common:\
                               bw-per-port",
                              "cir": "20480000"
                            }
                          ]
                        },
                        "svc-ce-to-pe-bandwidth": {
                          "ce-to-pe-bandwidth": [
                            {
                              "bw-type": "ietf-vpn-common:\
                               bw-per-port",
                              "cir": "20480000"
                            }
                          ]
                        },
                        "qos": {
                          "qos-profile": {
                            "qos-profile": [
                              {
                                "profile": "QoS_Profile_A",
                                "direction": "ietf-vpn-common:both"
                              }
                            ]
                          }
                        }
                      }
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "451",
                "description": "SEDE_CHAPINERO_451",
                "ne-id": "2001:db8:50::1",
                "role": "ietf-vpn-common:spoke-role",
                "status": {
                  "admin-status": {
                    "status": "ietf-vpn-common:admin-up"
                  }
                },
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "signaling-option": {
                  "ldp-or-l2tp": {
                    "t-ldp-pw-type": "vpls-type",
                    "pw-peer-list": [
                      {
                        "peer-addr": "2001:db8:5::1",
                        "vc-id": "1543"
                      }
                    ]
                  }
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "4508671288",
                      "description": "VPN_450_SNA",
                      "interface-id": "gigabithethernet0/0/1",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "l2-termination-point": "550",
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "tag-type": "ietf-vpn-common:c-vlan",
                            "cvlan-id": 550
                          }
                        }
                      },
                      "service": {
                        "mtu": 1550,
                        "svc-pe-to-ce-bandwidth": {
                          "pe-to-ce-bandwidth": [
                            {
                              "bw-type": "ietf-vpn-common:\
                               bw-per-port",
                              "cir": "20480000"
                            }
                          ]
                        },
                        "svc-ce-to-pe-bandwidth": {
                          "ce-to-pe-bandwidth": [
                            {
                              "bw-type": "ietf-vpn-common:\
                               bw-per-port",
                              "cir": "20480000"
                            }
                          ]
                        },
                        "qos": {
                          "qos-profile": {
                            "qos-profile": [
                              {
                                "profile": "QoS_Profile_A",
                                "direction": "ietf-vpn-common:both"
                              }
                            ]
                          }
                        }
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}

                   |<-------- EVPN Instance --------->|   
                   |                                  |  
             ESI1  V                                  V  ESI2
             |     +-----+   +--------------+   +-----+  |
      +----+ |     | PE1 |===|              |===| PE3 |  |    +----+
      |    +-------+     |   |              |   |     +-------+    |
      |    | |     +-----+   |              |   +-----+  |    |    |
      | CE1| |               |     Core     |            |    |CE2 |
      |    | |     +-----+   |              |   +-----+  |    |    |
      |    +-------+     |   |              |   |     +-------+    |
      +----+ |     | PE2 |===|              |===| PE4 |  |    +----+
           ^ |     +-----+   +--------------+   +-----+  |    ^
           | ESI1                                        ESI2 |
           |<-------------- Emulated Service ---------------->|

=============== NOTE: '\' line wrapping per RFC 8792 ================

{
  "ietf-ethernet-segment:ethernet-segments": {
    "ethernet-segment": [
      {
        "name": "esi1",
        "ethernet-segment-identifier": "00:11:11:11:11:11:11:\
         11:11:11",
        "esi-redundancy-mode": "all-active"
      },
      {
        "name": "esi2",
        "ethernet-segment-identifier": "00:22:22:22:22:22:22:\
         22:22:22",
        "esi-redundancy-mode": "all-active"
      }
    ]
  }
}

{
  "ietf-l2vpn-ntw:l2vpn-ntw": {
    "vpn-services": {
      "vpn-service": [
        {
          "vpn-id": "vpws15432855",
          "vpn-description": "Sample VPWS-EVPN",
          "customer-name": "customer_15432855",
          "vpn-type": "ietf-vpn-common:vpws-evpn",
          "bgp-ad-enabled": true,
          "signaling-type": "ietf-vpn-common:bgp-signaling",
          "global-parameters-profiles": {
            "global-parameters-profile": [
              {
                "profile-id": "simple-profile",
                "local-autonomous-system": 65535,
                "rd-suffix": 1,
                "vpn-target": [
                  {
                    "id": 1,
                    "route-targets": [
                      {
                        "route-target": "0:65535:1"
                      }
                    ],
                    "route-target-type": "both"
                  }
                ]
              }
            ]
          },
          "vpn-nodes": {
            "vpn-node": [
              {
                "vpn-node-id": "pe1",
                "ne-id": "198.51.100.1",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE1",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      },
                      "vpws-service-instance": {
                        "local-vpws-service-instance": 1111,
                        "remote-vpws-service-instance": 1112
                      },
                      "group": [
                        {
                          "group-id": "gr1",
                          "ethernet-segment-identifier": "esi1"
                        }
                      ]
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe2",
                "ne-id": "198.51.100.2",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE1",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      },
                      "vpws-service-instance": {
                        "local-vpws-service-instance": 1111,
                        "remote-vpws-service-instance": 1112
                      },
                      "group": [
                        {
                          "group-id": "gr1",
                          "ethernet-segment-identifier": "esi1"
                        }
                      ]
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe3",
                "ne-id": "198.51.100.3",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE2",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      },
                      "vpws-service-instance": {
                        "local-vpws-service-instance": 1112,
                        "remote-vpws-service-instance": 1111
                      },
                      "group": [
                        {
                          "group-id": "gr1",
                          "ethernet-segment-identifier": "esi2"
                        }
                      ]
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe4",
                "ne-id": "198.51.100.4",
                "active-global-parameters-profiles": {
                  "global-parameters-profile": [
                    {
                      "profile-id": "simple-profile"
                    }
                  ]
                },
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE2",
                      "active-vpn-node-profile": "simple-profile",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "encapsulation": {
                          "encap-type": "ietf-vpn-common:dot1q",
                          "dot1q": {
                            "cvlan-id": 1
                          }
                        }
                      },
                      "vpws-service-instance": {
                        "local-vpws-service-instance": 1112,
                        "remote-vpws-service-instance": 1111
                      },
                      "group": [
                        {
                          "group-id": "gr1",
                          "ethernet-segment-identifier": "esi2"
                        }
                      ]
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}

 
           ES      
           |     +-----+      +--------------+   +-----+    
    +----+ |     | PE1 |======|              |===| PE3 |       +----+
    |    +-------+     |      |              |   |     +-------+ CE3|
    |    | |     +-----+      |              |   +-----+       +----+
    | CE1| |                  |     Core     |                 
    |    | |     +-----+      |              |   +-----+       +----+
    |    +-------+     |      |              |   |     +-------+ CE2|
    +----+ |     | PE2 |======|              |===| PE4 |       +----+
           |     +-----+      +--------------+   +-----+          
         LACP 

{
  "ietf-ethernet-segment:ethernet-segments": {
    "ethernet-segment": [
      {
        "name": "esi1",
        "esi-type": "esi-type-1-lacp",
        "esi-redundancy-mode": "all-active"
      }
    ]
  }
}

{
  "ietf-l2vpn-ntw:l2vpn-ntw": {
    "ietf-l2vpn-ntw:vpn-services": {
      "vpn-service": [
        {
          "vpn-id": "auto-esi-lacp",
          "vpn-description": "Sample to illustrate auto-ESI",
          "vpn-type": "ietf-vpn-common:vpws-evpn",
          "vpn-nodes": {
            "vpn-node": [
              {
                "vpn-node-id": "pe1",
                "ne-id": "198.51.100.1",
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "1/1/1.1",
                      "interface-id": "1/1/1",
                      "description": "Interface to CE1",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "lag-interface": {
                          "lag-interface-id": "1",
                          "lacp": {
                            "lacp-state": true,
                            "system-id": "11:00:11:00:11:11",
                            "admin-key": 154
                          }
                        }
                      },
                      "group": [
                        {
                          "group-id": "gr1",
                          "ethernet-segment-identifier": "esi1"
                        }
                      ]
                    }
                  ]
                }
              },
              {
                "vpn-node-id": "pe2",
                "ne-id": "198.51.100.2",
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "2/2/2.5",
                      "interface-id": "2/2/2",
                      "description": "Interface to CE1",
                      "status": {
                        "admin-status": {
                          "status": "ietf-vpn-common:admin-up"
                        }
                      },
                      "connection": {
                        "lag-interface": {
                          "lag-interface-id": "1",
                          "lacp": {
                            "lacp-state": true,
                            "system-id": "11:00:11:00:11:11",
                            "admin-key": 154
                          }
                        }
                      },
                      "group": [
                        {
                          "group-id": "gr1",
                          "ethernet-segment-identifier": "esi1"
                        }
                      ]
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}

=============== NOTE: '\' line wrapping per RFC 8792 ================

{
  "ietf-ethernet-segment:ethernet-segments": {
    "ethernet-segment": [
      {
        "name": "esi1",
        "ethernet-segment-identifier": "esi-type-1-lacp",
        "esi-auto": {
          "auto-ethernet-segment-identifier": "01:11:00:11:00:11:\
           11:9a:00:00"
        },
        "esi-redundancy-mode": "all-active"
      }
    ]
  }
}

{
  "ietf-l2vpn-ntw:l2vpn-ntw": {
    "vpn-services": {
      "vpn-service": [
        {
          "vpn-id": "Sample-Service",
          "vpn-nodes": {
            "vpn-node": [
              {
                "vpn-node-id": "VPN-NODE",
                "vpn-network-accesses": {
                  "vpn-network-access": [
                    {
                      "id": "NET-ACC-1",
                      "connection": {
                        "bearer-reference": "br1"
                      },
                      "group": [
                        {
                          "group-id": "1",
                          "precedence": "primary"
                        }
                      ]
                    },
                    {
                      "id": "NET-ACC-2",
                      "connection": {
                        "bearer-reference": "br2"
                      },
                      "group": [
                        {
                          "group-id": "1",
                          "precedence": "secondary"
                        }
                      ]
                    }
                  ]
                }
              }
            ]
          }
        }
      ]
    }
  }
}