ietf-l2vpn-svc

This YANG module defines a generic service configuration model for Layer 2 VPN services common across all vendor implementations...

  • Version: 2018-10-09

    ietf-l2vpn-svc@2018-10-09


    
      module ietf-l2vpn-svc {
    
        yang-version 1.1;
    
        namespace
          "urn:ietf:params:xml:ns:yang:ietf-l2vpn-svc";
    
        prefix l2vpn-svc;
    
        import ietf-inet-types {
          prefix inet;
        }
        import ietf-yang-types {
          prefix yang;
        }
        import ietf-netconf-acm {
          prefix nacm;
        }
    
        organization "IETF L2SM Working Group.";
    
        contact
          "WG Web:   <https://datatracker.ietf.org/wg/l2sm/>
         WG List:  <mailto:l2sm@ietf.org>
         Editor:   Giuseppe Fioccola
                   <mailto:giuseppe.fioccola@tim.it>";
    
        description
          "This YANG module defines a generic service configuration model
         for Layer 2 VPN services common across all vendor
         implementations.
    
         Copyright (c) 2018 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 Simplified 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 8466;
         see the RFC itself for full legal notices.";
    
        revision "2018-10-09" {
          description "Initial revision.";
          reference
            "RFC 8466: A YANG Data Model for Layer 2 Virtual Private
            Network (L2VPN) Service Delivery";
    
        }
    
    
        feature carrierscarrier {
          description
            "Enables the support of carriers' carriers (CsC).";
        }
    
        feature ethernet-oam {
          description
            "Enables the support of Ethernet Service OAM.";
        }
    
        feature extranet-vpn {
          description
            "Enables the support of extranet VPNs.";
        }
    
        feature l2cp-control {
          description
            "Enables the support of L2CP control.";
        }
    
        feature input-bw {
          description
            "Enables the support of input bandwidth in a VPN.";
        }
    
        feature output-bw {
          description
            "Enables the support of output bandwidth in a VPN.";
        }
    
        feature uni-list {
          description
            "Enables the support of a list of UNIs in a VPN.";
        }
    
        feature cloud-access {
          description
            "Allows the VPN to connect to a Cloud Service Provider (CSP)
           or an ISP.";
        }
    
        feature oam-3ah {
          description
            "Enables the support of OAM 802.3ah.";
        }
    
        feature micro-bfd {
          description
            "Enables the support of micro-BFD.";
        }
    
        feature bfd {
          description
            "Enables the support of BFD.";
        }
    
        feature signaling-options {
          description
            "Enables the support of signaling options.";
        }
    
        feature site-diversity {
          description
            "Enables the support of site diversity constraints in a VPN.";
        }
    
        feature encryption {
          description
            "Enables the support of encryption.";
        }
    
        feature always-on {
          description
            "Enables support for the 'always-on' access constraint.";
        }
    
        feature requested-type {
          description
            "Enables support for the 'requested-type' access constraint.";
        }
    
        feature bearer-reference {
          description
            "Enables support for the 'bearer-reference' access
           constraint.";
        }
    
        feature qos {
          description "Enables support for QoS.";
        }
    
        feature qos-custom {
          description
            "Enables the support of a custom QoS profile.";
        }
    
        feature lag-interface {
          description "Enables LAG interfaces.";
        }
    
        feature vlan {
          description
            "Enables the support of VLANs.";
        }
    
        feature dot1q {
          description
            "Enables the support of dot1Q.";
        }
    
        feature qinq {
          description
            "Enables the support of QinQ.";
        }
    
        feature qinany {
          description
            "Enables the support of QinAny.";
        }
    
        feature vxlan {
          description
            "Enables the support of VXLANs.";
        }
    
        feature lan-tag {
          description
            "Enables LAN tag support in a VPN.";
        }
    
        feature target-sites {
          description
            "Enables the support of the 'target-sites'
           match-flow parameter.";
        }
    
        feature bum {
          description
            "Enables BUM capabilities in a VPN.";
        }
    
        feature mac-loop-prevention {
          description
            "Enables the MAC loop-prevention capability in a VPN.";
        }
    
        feature lacp {
          description
            "Enables the Link Aggregation Control Protocol (LACP)
           capability in a VPN.";
        }
    
        feature mac-addr-limit {
          description
            "Enables the MAC address limit capability in a VPN.";
        }
    
        feature acl {
          description
            "Enables the ACL capability in a VPN.";
        }
    
        feature cfm {
          description
            "Enables the 802.1ag CFM capability in a VPN.";
        }
    
        feature y-1731 {
          description
            "Enables the Y.1731 capability in a VPN.";
        }
    
        typedef svc-id {
          type string;
          description
            "Defines the type of service component identifier.";
        }
    
        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.";
        }
    
        typedef control-mode {
          type enumeration {
            enum "peer" {
              value 0;
              description
                "'peer' mode, i.e., participate in the protocol towards
               the CE.  Peering is common for LACP and the Ethernet
               Local Management Interface (E-LMI) and, occasionally,
               for LLDP.  For VPLSs and VPWSs, the subscriber can also
               request that the SP peer enable spanning tree.";
            }
            enum "tunnel" {
              value 1;
              description
                "'tunnel' mode, i.e., pass to the egress or destination
               site.  For EPLs, the expectation is that L2CP frames are
               tunneled.";
            }
            enum "discard" {
              value 2;
              description
                "'discard' mode, i.e., discard the frame.";
            }
          }
          description
            "Defines the type of control mode on L2CP protocols.";
        }
    
        typedef neg-mode {
          type enumeration {
            enum "full-duplex" {
              value 0;
              description
                "Defines full-duplex mode.";
            }
            enum "auto-neg" {
              value 1;
              description
                "Defines auto-negotiation mode.";
            }
          }
          description
            "Defines the type of negotiation mode.";
        }
    
        identity site-network-access-type {
          description
            "Base identity for the site-network-access type.";
        }
    
        identity point-to-point {
          base site-network-access-type;
          description
            "Identity for a point-to-point connection.";
        }
    
        identity multipoint {
          base site-network-access-type;
          description
            "Identity for a multipoint connection, e.g.,
           an Ethernet broadcast segment.";
        }
    
        identity tag-type {
          description
            "Base identity from which all tag types are derived.";
        }
    
        identity c-vlan {
          base tag-type;
          description
            "A CVLAN tag, normally using the 0x8100 Ethertype.";
        }
    
        identity s-vlan {
          base tag-type;
          description "An SVLAN tag.";
        }
    
        identity c-s-vlan {
          base tag-type;
          description
            "Using both a CVLAN tag and an SVLAN tag.";
        }
    
        identity multicast-tree-type {
          description
            "Base identity for the multicast tree type.";
        }
    
        identity ssm-tree-type {
          base multicast-tree-type;
          description
            "Identity for the Source-Specific Multicast (SSM) tree type.";
          reference
            "RFC 8299: YANG Data Model for L3VPN Service Delivery";
    
        }
    
        identity asm-tree-type {
          base multicast-tree-type;
          description
            "Identity for the Any-Source Multicast (ASM) tree type.";
          reference
            "RFC 8299: YANG Data Model for L3VPN Service Delivery";
    
        }
    
        identity bidir-tree-type {
          base multicast-tree-type;
          description
            "Identity for the bidirectional tree type.";
          reference
            "RFC 8299: YANG Data Model for L3VPN Service Delivery";
    
        }
    
        identity multicast-gp-address-mapping {
          description
            "Identity for mapping type.";
        }
    
        identity static-mapping {
          base multicast-gp-address-mapping;
          description
            "Identity for static mapping, i.e., attach the interface
           to the multicast group as a static member.";
        }
    
        identity dynamic-mapping {
          base multicast-gp-address-mapping;
          description
            "Identity for dynamic mapping, i.e., an interface was added
           to the multicast group as a result of snooping.";
        }
    
        identity tf-type {
          description
            "Identity for the traffic type.";
        }
    
        identity multicast-traffic {
          base tf-type;
          description
            "Identity for multicast traffic.";
        }
    
        identity broadcast-traffic {
          base tf-type;
          description
            "Identity for broadcast traffic.";
        }
    
        identity unknown-unicast-traffic {
          base tf-type;
          description
            "Identity for unknown unicast traffic.";
        }
    
        identity encapsulation-type {
          description
            "Identity for the encapsulation type.";
        }
    
        identity ethernet {
          base encapsulation-type;
          description
            "Identity for Ethernet type.";
        }
    
        identity vlan {
          base encapsulation-type;
          description
            "Identity for the VLAN type.";
        }
    
        identity carrierscarrier-type {
          description
            "Identity of the CsC type.";
        }
    
        identity ldp {
          base carrierscarrier-type;
          description
            "Use LDP as the signaling protocol
           between the PE and the CE.";
        }
    
        identity bgp {
          base carrierscarrier-type;
          description
            "Use BGP (as per RFC 8277) as the signaling protocol
           between the PE and the CE.
           In this case, BGP must also be configured as
           the routing protocol.";
        }
    
        identity eth-inf-type {
          description
            "Identity of the Ethernet interface type.";
        }
    
        identity tagged {
          base eth-inf-type;
          description
            "Identity of the tagged interface type.";
        }
    
        identity untagged {
          base eth-inf-type;
          description
            "Identity of the untagged interface type.";
        }
    
        identity lag {
          base eth-inf-type;
          description
            "Identity of the LAG interface type.";
        }
    
        identity bw-type {
          description
            "Identity of the bandwidth type.";
        }
    
        identity bw-per-cos {
          base bw-type;
          description "Bandwidth is per CoS.";
        }
    
        identity bw-per-port {
          base bw-type;
          description
            "Bandwidth is per site network access.";
        }
    
        identity bw-per-site {
          base bw-type;
          description
            "Bandwidth is per site.  It is applicable to
           all the site network accesses within the site.";
        }
    
        identity bw-per-svc {
          base bw-type;
          description
            "Bandwidth is per VPN service.";
        }
    
        identity site-vpn-flavor {
          description
            "Base identity for the site VPN service flavor.";
        }
    
        identity site-vpn-flavor-single {
          base site-vpn-flavor;
          description
            "Identity for the site VPN service flavor.
           Used when the site belongs to only one VPN.";
        }
    
        identity site-vpn-flavor-multi {
          base site-vpn-flavor;
          description
            "Identity for the site VPN service flavor.
           Used when a logical connection of a site
           belongs to multiple VPNs.";
        }
    
        identity site-vpn-flavor-nni {
          base site-vpn-flavor;
          description
            "Identity for the site VPN service flavor.
           Used to describe an NNI option A connection.";
        }
    
        identity service-type {
          description
            "Base identity of the service type.";
        }
    
        identity vpws {
          base service-type;
          description
            "Point-to-point Virtual Private Wire Service (VPWS)
           service type.";
        }
    
        identity pwe3 {
          base service-type;
          description
            "Pseudowire Emulation Edge to Edge (PWE3) service type.";
        }
    
        identity ldp-l2tp-vpls {
          base service-type;
          description
            "LDP-based or L2TP-based multipoint Virtual Private LAN
           Service (VPLS) service type.  This VPLS uses LDP-signaled
           Pseudowires or L2TP-signaled Pseudowires.";
        }
    
        identity bgp-vpls {
          base service-type;
          description
            "BGP-based multipoint VPLS service type.  This VPLS uses a
           BGP control plane as described in RFCs 4761 and 6624.";
        }
    
        identity vpws-evpn {
          base service-type;
          description
            "VPWS service type using Ethernet VPNs (EVPNs)
           as specified in RFC 7432.";
        }
    
        identity pbb-evpn {
          base service-type;
          description
            "Provider Backbone Bridge (PBB) service type using
           EVPNs as specified in RFC 7432.";
        }
    
        identity bundling-type {
          description
            "The base identity for the bundling type.  It supports
           multiple CE-VLANs associated with an L2VPN service or
           all CE-VLANs associated with an L2VPN service.";
        }
    
        identity multi-svc-bundling {
          base bundling-type;
          description
            "Identity for multi-service bundling, i.e.,
           multiple CE-VLAN IDs can be associated with an
           L2VPN service at a site.";
        }
    
        identity one2one-bundling {
          base bundling-type;
          description
            "Identity for one-to-one service bundling, i.e.,
           each L2VPN can be associated with only one CE-VLAN ID
           at a site.";
        }
    
        identity all2one-bundling {
          base bundling-type;
          description
            "Identity for all-to-one bundling, i.e., all CE-VLAN IDs
           are mapped to one L2VPN service.";
        }
    
        identity color-id {
          description
            "Base identity of the color ID.";
        }
    
        identity color-id-cvlan {
          base color-id;
          description
            "Identity of the color ID based on a CVLAN.";
        }
    
        identity cos-id {
          description "Identity of the CoS ID.";
        }
    
        identity cos-id-pcp {
          base cos-id;
          description
            "Identity of the CoS ID based on the
           Port Control Protocol (PCP).";
        }
    
        identity cos-id-dscp {
          base cos-id;
          description
            "Identity of the CoS ID based on DSCP.";
        }
    
        identity color-type {
          description "Identity of color types.";
        }
    
        identity green {
          base color-type;
          description
            "Identity of the 'green' color type.";
        }
    
        identity yellow {
          base color-type;
          description
            "Identity of the 'yellow' color type.";
        }
    
        identity red {
          base color-type;
          description
            "Identity of the 'red' color type.";
        }
    
        identity policing {
          description
            "Identity of the type of policing applied.";
        }
    
        identity one-rate-two-color {
          base policing;
          description
            "Identity of one-rate, two-color (1R2C).";
        }
    
        identity two-rate-three-color {
          base policing;
          description
            "Identity of two-rate, three-color (2R3C).";
        }
    
        identity bum-type {
          description
            "Identity of the BUM type.";
        }
    
        identity broadcast {
          base bum-type;
          description "Identity of broadcast.";
        }
    
        identity unicast {
          base bum-type;
          description "Identity of unicast.";
        }
    
        identity multicast {
          base bum-type;
          description "Identity of multicast.";
        }
    
        identity loop-prevention-type {
          description
            "Identity of loop prevention.";
        }
    
        identity shut {
          base loop-prevention-type;
          description
            "Identity of shut protection.";
        }
    
        identity trap {
          base loop-prevention-type;
          description
            "Identity of trap protection.";
        }
    
        identity lacp-state {
          description
            "Identity of the LACP state.";
        }
    
        identity lacp-on {
          base lacp-state;
          description "Identity of LACP on.";
        }
    
        identity lacp-off {
          base lacp-state;
          description "Identity of LACP off.";
        }
    
        identity lacp-mode {
          description
            "Identity of the LACP mode.";
        }
    
        identity lacp-passive {
          base lacp-mode;
          description
            "Identity of LACP passive.";
        }
    
        identity lacp-active {
          base lacp-mode;
          description "Identity of LACP active.";
        }
    
        identity lacp-speed {
          description
            "Identity of the LACP speed.";
        }
    
        identity lacp-fast {
          base lacp-speed;
          description "Identity of LACP fast.";
        }
    
        identity lacp-slow {
          base lacp-speed;
          description "Identity of LACP slow.";
        }
    
        identity bw-direction {
          description
            "Identity for the bandwidth direction.";
        }
    
        identity input-bw {
          base bw-direction;
          description
            "Identity for the input bandwidth.";
        }
    
        identity output-bw {
          base bw-direction;
          description
            "Identity for the output bandwidth.";
        }
    
        identity management {
          description
            "Base identity for the site management scheme.";
        }
    
        identity co-managed {
          base management;
          description
            "Identity for a co-managed site.";
        }
    
        identity customer-managed {
          base management;
          description
            "Identity for a customer-managed site.";
        }
    
        identity provider-managed {
          base management;
          description
            "Identity for a provider-managed site.";
        }
    
        identity address-family {
          description
            "Identity for an address family.";
        }
    
        identity ipv4 {
          base address-family;
          description
            "Identity for an IPv4 address family.";
        }
    
        identity ipv6 {
          base address-family;
          description
            "Identity for an IPv6 address family.";
        }
    
        identity vpn-topology {
          description
            "Base identity for the VPN topology.";
        }
    
        identity any-to-any {
          base vpn-topology;
          description
            "Identity for the any-to-any VPN topology.";
        }
    
        identity hub-spoke {
          base vpn-topology;
          description
            "Identity for the Hub-and-Spoke VPN topology.";
        }
    
        identity hub-spoke-disjoint {
          base vpn-topology;
          description
            "Identity for the Hub-and-Spoke VPN topology,
           where Hubs cannot communicate with each other.";
        }
    
        identity site-role {
          description
            "Base identity for a site type.";
        }
    
        identity any-to-any-role {
          base site-role;
          description
            "Site in an any-to-any L2VPN.";
        }
    
        identity spoke-role {
          base site-role;
          description
            "Spoke site in a Hub-and-Spoke L2VPN.";
        }
    
        identity hub-role {
          base site-role;
          description
            "Hub site in a Hub-and-Spoke L2VPN.";
        }
    
        identity pm-type {
          description
            "Performance-monitoring type.";
        }
    
        identity loss {
          base pm-type;
          description "Loss measurement.";
        }
    
        identity delay {
          base pm-type;
          description "Delay measurement.";
        }
    
        identity fault-alarm-defect-type {
          description
            "Indicates the alarm-priority defect (i.e., the
           lowest-priority defect that is allowed to
           generate a fault alarm).";
        }
    
        identity remote-rdi {
          base fault-alarm-defect-type;
          description
            "Indicates the aggregate health
           of the Remote MEPs.";
        }
    
        identity remote-mac-error {
          base fault-alarm-defect-type;
          description
            "Indicates that one or more of the Remote MEPs are
           reporting a failure in their Port Status TLVs or
           Interface Status TLVs.";
        }
    
        identity remote-invalid-ccm {
          base fault-alarm-defect-type;
          description
            "Indicates that at least one of the Remote MEP
           state machines is not receiving valid
           Continuity Check Messages (CCMs) from its Remote MEP.";
        }
    
        identity invalid-ccm {
          base fault-alarm-defect-type;
          description
            "Indicates that one or more invalid CCMs have been
           received and that a period of time 3.5 times the length
           of those CCMs' transmission intervals has not yet expired.";
        }
    
        identity cross-connect-ccm {
          base fault-alarm-defect-type;
          description
            "Indicates that one or more cross-connect CCMs have been
           received and that 3.5 times the period of at least one of
           those CCMs' transmission intervals has not yet expired.";
        }
    
        identity frame-delivery-mode {
          description "Delivery types.";
        }
    
        identity discard {
          base frame-delivery-mode;
          description
            "Service frames are discarded.";
        }
    
        identity unconditional {
          base frame-delivery-mode;
          description
            "Service frames are unconditionally delivered to the
           destination site.";
        }
    
        identity unknown-discard {
          base frame-delivery-mode;
          description
            "Service frames are conditionally delivered to the
           destination site.  Packets with unknown destination addresses
           will be discarded.";
        }
    
        identity placement-diversity {
          description
            "Base identity for site placement constraints.";
        }
    
        identity bearer-diverse {
          base placement-diversity;
          description
            "Identity for bearer diversity.
           The bearers should not use common elements.";
        }
    
        identity pe-diverse {
          base placement-diversity;
          description
            "Identity for PE diversity.";
        }
    
        identity pop-diverse {
          base placement-diversity;
          description
            "Identity for POP diversity.";
        }
    
        identity linecard-diverse {
          base placement-diversity;
          description
            "Identity for linecard diversity.";
        }
    
        identity same-pe {
          base placement-diversity;
          description
            "Identity for having sites connected on the same PE.";
        }
    
        identity same-bearer {
          base placement-diversity;
          description
            "Identity for having sites connected using the same bearer.";
        }
    
        identity tagged-inf-type {
          description
            "Identity for the tagged interface type.";
        }
    
        identity priority-tagged {
          base tagged-inf-type;
          description
            "Identity for the priority-tagged interface.";
        }
    
        identity qinq {
          base tagged-inf-type;
          description
            "Identity for the QinQ tagged interface.";
        }
    
        identity dot1q {
          base tagged-inf-type;
          description
            "Identity for the dot1Q VLAN tagged interface.";
        }
    
        identity qinany {
          base tagged-inf-type;
          description
            "Identity for the QinAny tagged interface.";
        }
    
        identity vxlan {
          base tagged-inf-type;
          description
            "Identity for the VXLAN tagged interface.";
        }
    
        identity provision-model {
          description
            "Base identity for the provision model.";
        }
    
        identity single-side-provision {
          description
            "Identity for single-sided provisioning with discovery.";
        }
    
        identity doubled-side-provision {
          description
            "Identity for double-sided provisioning.";
        }
    
        identity mac-learning-mode {
          description "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 vpn-policy-filter-type {
          description
            "Base identity for the filter type.";
        }
    
        identity lan {
          base vpn-policy-filter-type;
          description
            "Identity for a LAN tag filter type.";
        }
    
        identity mac-action {
          description
            "Base identity for a MAC action.";
        }
    
        identity drop {
          base mac-action;
          description
            "Identity for dropping a packet.";
        }
    
        identity flood {
          base mac-action;
          description
            "Identity for packet flooding.";
        }
    
        identity warning {
          base mac-action;
          description
            "Identity for sending a warning log message.";
        }
    
        identity qos-profile-direction {
          description
            "Base identity for the QoS-profile direction.";
        }
    
        identity site-to-wan {
          base qos-profile-direction;
          description
            "Identity for the site-to-WAN direction.";
        }
    
        identity wan-to-site {
          base qos-profile-direction;
          description
            "Identity for the WAN-to-site direction.";
        }
    
        identity bidirectional {
          base qos-profile-direction;
          description
            "Identity for both the WAN-to-site direction
           and the site-to-WAN direction.";
        }
    
        identity vxlan-peer-mode {
          description
            "Base identity for the VXLAN peer mode.";
        }
    
        identity static-mode {
          base vxlan-peer-mode;
          description
            "Identity for VXLAN access in the static mode.";
        }
    
        identity bgp-mode {
          base vxlan-peer-mode;
          description
            "Identity for VXLAN access by BGP EVPN learning.";
        }
    
        identity customer-application {
          description
            "Base identity for a customer application.";
        }
    
        identity web {
          base customer-application;
          description
            "Identity for a web application (e.g., HTTP, HTTPS).";
        }
    
        identity mail {
          base customer-application;
          description
            "Identity for a mail application.";
        }
    
        identity file-transfer {
          base customer-application;
          description
            "Identity for a file-transfer application
           (e.g., FTP, SFTP).";
        }
    
        identity database {
          base customer-application;
          description
            "Identity for a database application.";
        }
    
        identity social {
          base customer-application;
          description
            "Identity for a social-network application.";
        }
    
        identity games {
          base customer-application;
          description
            "Identity for a gaming application.";
        }
    
        identity p2p {
          base customer-application;
          description
            "Identity for a peer-to-peer application.";
        }
    
        identity network-management {
          base customer-application;
          description
            "Identity for a management application
           (e.g., Telnet, syslog, SNMP).";
        }
    
        identity voice {
          base customer-application;
          description
            "Identity for a voice application.";
        }
    
        identity video {
          base customer-application;
          description
            "Identity for a videoconference application.";
        }
    
        identity embb {
          base customer-application;
          description
            "Identity for the enhanced Mobile Broadband (eMBB)
           application.  Note that the eMBB application
           requires strict threshold values for a wide variety
           of network performance parameters (e.g., data rate,
           latency, loss rate, reliability).";
        }
    
        identity urllc {
          base customer-application;
          description
            "Identity for the Ultra-Reliable and Low Latency
           Communications (URLLC) application.  Note that the
           URLLC application requires strict threshold values for
           a wide variety of network performance parameters
           (e.g., latency, reliability).";
        }
    
        identity mmtc {
          base customer-application;
          description
            "Identity for the massive Machine Type
           Communications (mMTC) application.  Note that the
           mMTC application requires strict threshold values for
           a wide variety of network performance parameters
           (e.g., data rate, latency, loss rate, reliability).";
        }
    
        grouping site-acl {
          description
            "Grouping that defines the ACL.";
          container access-control-list {
            if-feature acl;
            description "Container for the ACL.";
            list mac {
              key "mac-address";
              description
                "List of MAC addresses.";
              leaf mac-address {
                type yang:mac-address;
                description "MAC addresses.";
              }
            }  // list mac
          }  // container access-control-list
        }  // grouping site-acl
    
        grouping site-bum {
          description "Grouping for BUM.";
          container broadcast-unknown-unicast-multicast {
            if-feature bum;
            description
              "Container of BUM configurations.";
            leaf multicast-site-type {
              type enumeration {
                enum "receiver-only" {
                  value 0;
                  description
                    "The site only has receivers.";
                }
                enum "source-only" {
                  value 1;
                  description
                    "The site only has sources.";
                }
                enum "source-receiver" {
                  value 2;
                  description
                    "The site has both sources and receivers.";
                }
              }
              default "source-receiver";
              description
                "Type of 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 uint16 {
                  range "0..1024";
                }
                mandatory true;
                description
                  "The VLAN ID of the multicast group.
                 The range of the 12-bit VLAN ID is 0 to 1024.";
              }
    
              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 ports/LAGs belonging to the multicast group.";
              }
            }  // list multicast-gp-address-mapping
    
            leaf bum-overall-rate {
              type uint64;
              units "bps";
              description
                "Overall rate for BUM.";
            }
    
            list bum-rate-per-type {
              key "type";
              description
                "List of limit rates for the BUM type.";
              leaf type {
                type identityref {
                  base bum-type;
                }
                description "BUM type.";
              }
    
              leaf rate {
                type uint64;
                units "bps";
                description "Rate for BUM.";
              }
            }  // list bum-rate-per-type
          }  // container broadcast-unknown-unicast-multicast
        }  // grouping site-bum
    
        grouping site-mac-loop-prevention {
          description
            "Grouping for MAC loop prevention.";
          container mac-loop-prevention {
            if-feature mac-loop-prevention;
            description
              "Container of MAC loop-prevention parameters.";
            leaf protection-type {
              type identityref {
                base loop-prevention-type;
              }
              default "trap";
              description
                "Protection type.  By default, the protection
               type is 'trap'.";
            }
    
            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.  By default, the number of
               times is 5.";
            }
    
            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.";
            }
          }  // container mac-loop-prevention
        }  // grouping site-mac-loop-prevention
    
        grouping site-service-qos-profile {
          description
            "Grouping that defines QoS parameters for a site.";
          container qos {
            if-feature 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 marking rules.";
                leaf id {
                  type string;
                  description
                    "A description identifying the QoS classification
                   policy rule.";
                }
    
                choice match-type {
                  default "match-flow";
                  description
                    "Choice for classification.";
                  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.";
                    }
    
                    leaf pcp {
                      type uint8 {
                        range "0..7";
                      }
                      description "PCP value.";
                    }
    
                    leaf src-mac {
                      type yang:mac-address;
                      description "Source MAC.";
                    }
    
                    leaf dst-mac {
                      type yang:mac-address;
                      description
                        "Destination MAC.";
                    }
    
                    leaf color-type {
                      type identityref {
                        base color-type;
                      }
                      description "Color types.";
                    }
    
                    leaf-list target-sites {
                      if-feature target-sites;
                      type svc-id;
                      description
                        "Identifies a site as a traffic destination.";
                    }
    
                    leaf any {
                      type empty;
                      description "Allow all.";
                    }
    
                    leaf vpn-id {
                      type svc-id;
                      description
                        "Reference to the target VPN.";
                    }
                  }  // container match-flow
                  leaf match-application {
                    type identityref {
                      base customer-application;
                    }
                    description
                      "Defines the application to match.";
                  }
                }  // choice match-type
    
                leaf target-class-id {
                  type string;
                  description
                    "Identification of the CoS.
                   This identifier is internal to the
                   administration.";
                }
              }  // list rule
            }  // container qos-classification-policy
    
            container qos-profile {
              description
                "Qos profile configuration.";
              choice qos-profile {
                description
                  "Choice for the QoS profile.
                 Can be a standard profile or a customized profile.";
                case standard {
                  description
                    "Standard QoS profile.";
                  leaf profile {
                    type leafref {
                      path
                        "/l2vpn-svc/vpn-profiles/"
                          + "valid-provider-identifiers/"
                          + "qos-profile-identifier";
                    }
                    description
                      "QoS profile to be used.";
                  }
                }  // case standard
    
                case custom {
                  description
                    "Customized QoS profile.";
                  container classes {
                    if-feature qos-custom;
                    description
                      "Container for list of CoS entries.";
                    list class {
                      key "class-id";
                      description
                        "List of CoS entries.";
                      leaf class-id {
                        type string;
                        description
                          "Identification of the CoS.  This identifier is
                         internal to the administration.";
                      }
    
                      leaf direction {
                        type identityref {
                          base qos-profile-direction;
                        }
                        default "bidirectional";
                        description
                          "The direction in which the QoS profile is
                         applied.  By default, the direction is
                         bidirectional.";
                      }
    
                      leaf policing {
                        type identityref {
                          base policing;
                        }
                        default
                          "one-rate-two-color";
                        description
                          "The policing type can be either one-rate,
                         two-color (1R2C) or two-rate, three-color
                         (2R3C).  By default, the policing type is
                         'one-rate-two-color'.";
                      }
    
                      leaf byte-offset {
                        type uint16;
                        description
                          "Number of bytes in the service frame header
                         that are excluded from the QoS calculation
                         (e.g., extra VLAN tags).";
                      }
    
                      container frame-delay {
                        description
                          "Delay constraint on the traffic class.";
                        choice flavor {
                          description
                            "Delay constraint on the traffic class.";
                          leaf use-lowest-latency {
                            type empty;
                            description
                              "The traffic class should use the path
                               with the lowest delay.";
                          }
                          leaf delay-bound {
                            type uint16;
                            units "milliseconds";
                            description
                              "The traffic class should use a path
                               with a defined maximum delay.";
                          }
                        }  // choice flavor
                      }  // container frame-delay
    
                      container frame-jitter {
                        description
                          "Jitter constraint on the traffic class.";
                        choice flavor {
                          description
                            "Jitter constraint on the traffic class.";
                          leaf use-lowest-jitter {
                            type empty;
                            description
                              "The traffic class should use the path
                               with the lowest jitter.";
                          }
                          leaf delay-bound {
                            type uint32;
                            units "microseconds";
                            description
                              "The traffic class should use a path
                               with a defined maximum jitter.";
                          }
                        }  // choice flavor
                      }  // container frame-jitter
    
                      container frame-loss {
                        description
                          "Container for frame loss rate.";
                        leaf rate {
                          type decimal64 {
                            fraction-digits 2;
                            range "0..100";
                          }
                          units "percent";
                          description
                            "Frame loss rate constraint on the traffic
                           class.";
                        }
                      }  // container frame-loss
    
                      container bandwidth {
                        description
                          "Bandwidth constraint on the traffic class.";
                        leaf guaranteed-bw-percent {
                          type decimal64 {
                            fraction-digits 5;
                            range "0..100";
                          }
                          units "percent";
                          mandatory true;
                          description
                            "Used to define the guaranteed bandwidth
                           as a percentage of the available service
                           bandwidth.";
                        }
    
                        leaf end-to-end {
                          type empty;
                          description
                            "Used if the bandwidth reservation
                           must be done on the MPLS network too.";
                        }
                      }  // container bandwidth
                    }  // list class
                  }  // container classes
                }  // case custom
              }  // choice qos-profile
            }  // container qos-profile
          }  // container qos
        }  // grouping site-service-qos-profile
    
        grouping site-service-mpls {
          description "Grouping for CsC.";
          container carrierscarrier {
            if-feature carrierscarrier;
            description "Container for CsC.";
            leaf signaling-type {
              type identityref {
                base carrierscarrier-type;
              }
              default "bgp";
              description
                "CsC.  By default, the signaling type is 'bgp'.";
            }
          }  // container carrierscarrier
        }  // grouping site-service-mpls
    
        container l2vpn-svc {
          description
            "Container for L2VPN services.";
          container vpn-profiles {
            description
              "Container for VPN profiles.";
            container valid-provider-identifiers {
              nacm:default-deny-write;
              description
                "Container for valid provider identifiers.";
              leaf-list cloud-identifier {
                if-feature cloud-access;
                type string;
                description
                  "Identification of the public cloud service or
                 Internet service.  Local to each administration.";
              }
    
              leaf-list qos-profile-identifier {
                type string;
                description
                  "Identification of the QoS profile to be used.
                 Local to each administration.";
              }
    
              leaf-list bfd-profile-identifier {
                type string;
                description
                  "Identification of the SP BFD profile to be used.
                 Local to each administration.";
              }
    
              leaf-list remote-carrier-identifier {
                type string;
                description
                  "Identification of the remote carrier name to be used.
                 It can be an L2VPN partner, data-center SP, or
                 private CSP.  Local to each administration.";
              }
            }  // container valid-provider-identifiers
          }  // container vpn-profiles
    
          container vpn-services {
            description
              "Container for VPN services.";
            list vpn-service {
              key "vpn-id";
              description
                "List of VPN services.";
              leaf vpn-id {
                type svc-id;
                description
                  "Defines a service identifier.";
              }
    
              leaf vpn-svc-type {
                type identityref {
                  base service-type;
                }
                default "vpws";
                description
                  "Service type.  By default, the service type is 'vpws'.";
              }
    
              leaf customer-name {
                type string;
                description "Customer name.";
              }
    
              leaf svc-topo {
                type identityref {
                  base vpn-topology;
                }
                default "any-to-any";
                description
                  "Defines the service topology, e.g.,
                 'any-to-any', 'hub-spoke'.";
              }
    
              container cloud-accesses {
                if-feature cloud-access;
                description
                  "Container for cloud access configurations.";
                list cloud-access {
                  key "cloud-identifier";
                  description
                    "Cloud access configuration.";
                  leaf cloud-identifier {
                    type leafref {
                      path "/l2vpn-svc/vpn-profiles/valid-provider-identifiers/cloud-identifier";
                    }
                    description
                      "Identification of the cloud service.
                     Local to each administration.";
                  }
    
                  choice list-flavor {
                    description
                      "Choice for cloud access policy.
                     By default, all sites in the L2VPN
                     MUST be authorized to access the cloud.";
                    leaf permit-any {
                      type empty;
                      description
                        "Allow all sites.";
                    }
                    leaf-list permit-site {
                      type leafref {
                        path "/l2vpn-svc/sites/site/site-id";
                      }
                      description
                        "Site ID to be authorized.";
                    }
                    leaf-list deny-site {
                      type leafref {
                        path "/l2vpn-svc/sites/site/site-id";
                      }
                      description
                        "Site ID to be denied.";
                    }
                  }  // choice list-flavor
                }  // list cloud-access
              }  // container cloud-accesses
    
              container frame-delivery {
                if-feature bum;
                description
                  "Multicast global parameters for the VPN service.";
                container customer-tree-flavors {
                  description
                    "Types of trees used by the customer.";
                  leaf-list tree-flavor {
                    type identityref {
                      base multicast-tree-type;
                    }
                    description
                      "Type of tree to be used.";
                  }
                }  // container customer-tree-flavors
    
                container bum-deliveries {
                  description
                    "Defines the frame delivery types and modes.";
                  list bum-delivery {
                    key "frame-type";
                    description
                      "List of frame delivery types and modes.";
                    leaf frame-type {
                      type identityref {
                        base tf-type;
                      }
                      description
                        "Type of frame delivery.  It supports unicast
                       frame delivery, multicast frame delivery,
                       and broadcast frame delivery.";
                    }
    
                    leaf delivery-mode {
                      type identityref {
                        base frame-delivery-mode;
                      }
                      default "unconditional";
                      description
                        "Defines the frame delivery mode
                       ('unconditional' (default), 'conditional',
                       or 'discard').  By default, service frames are
                       unconditionally delivered to the destination site.";
                    }
                  }  // list bum-delivery
                }  // container bum-deliveries
    
                leaf multicast-gp-port-mapping {
                  type identityref {
                    base multicast-gp-address-mapping;
                  }
                  mandatory true;
                  description
                    "Describes the way in which each interface is
                   associated with the multicast group.";
                }
              }  // container frame-delivery
    
              container extranet-vpns {
                if-feature extranet-vpn;
                description
                  "Container for extranet VPN configurations.";
                list extranet-vpn {
                  key "vpn-id";
                  description
                    "List of extranet VPNs to which the local VPN
                   is attached.";
                  leaf vpn-id {
                    type svc-id;
                    description
                      "Identifies the target VPN that the local VPN wants to
                     access.";
                  }
    
                  leaf local-sites-role {
                    type identityref {
                      base site-role;
                    }
                    default "any-to-any-role";
                    description
                      "Describes the role of the local sites in the target
                     VPN topology.  In the any-to-any VPN service topology,
                     the local sites must have the same role, which will be
                     'any-to-any-role'.  In the Hub-and-Spoke VPN service
                     topology or the Hub-and-Spoke-Disjoint VPN service
                     topology, the local sites must have a Hub role or a
                     Spoke role.";
                  }
                }  // list extranet-vpn
              }  // container extranet-vpns
    
              leaf ce-vlan-preservation {
                type boolean;
                mandatory true;
                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 IDs 1 through 4094.";
              }
    
              leaf ce-vlan-cos-preservation {
                type boolean;
                mandatory true;
                description
                  "CE VLAN CoS preservation.  The 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 carrierscarrier {
                if-feature carrierscarrier;
                type boolean;
                default "false";
                description
                  "The VPN is using CsC, and so MPLS is required.";
              }
            }  // list vpn-service
          }  // container vpn-services
    
          container sites {
            description
              "Container of site configurations.";
            list site {
              key "site-id";
              description "List of sites.";
              leaf site-id {
                type string;
                description
                  "Identifier of the site.";
              }
    
              leaf site-vpn-flavor {
                type identityref {
                  base site-vpn-flavor;
                }
                default "site-vpn-flavor-single";
                description
                  "Defines the way that the VPN multiplexing is
                 done, e.g., whether the site belongs to
                 a single VPN site or a multi-VPN site.  By
                 default, the site belongs to a single VPN.";
              }
    
              container devices {
                when
                  "derived-from-or-self(../management/type, "
                    + "'l2vpn-svc:provider-managed') or "
                    + "derived-from-or-self(../management/type, "
                    + "'l2vpn-svc:co-managed')" {
                  description
                    "Applicable only for a provider-managed or
                   co-managed device.";
                }
                description
                  "Device configurations.";
                list device {
                  key "device-id";
                  description
                    "List of devices requested by the customer.";
                  leaf device-id {
                    type string;
                    description
                      "Identifier for the device.";
                  }
    
                  leaf location {
                    type leafref {
                      path "../../../locations/location/location-id";
                    }
                    mandatory true;
                    description
                      "Location of the device.";
                  }
    
                  container management {
                    when
                      "derived-from-or-self(../../../management/type, "
                        + "'l2vpn-svc:co-managed')" {
                      description
                        "Applicable only for a co-managed device.";
                    }
                    description
                      "Management configuration.  Applicable only for a
                     co-managed device.";
                    leaf transport {
                      type identityref {
                        base address-family;
                      }
                      description
                        "Transport protocol or address family
                       used for management.";
                    }
    
                    leaf address {
                      when '(../ transport)' {
                        description
                          "If the address family is specified, then the
                         address should also be specified.  If the
                         transport is not specified, then the address
                         should not be specified.";
                      }
                      type inet:ip-address;
                      description
                        "Management address.";
                    }
                  }  // container management
                }  // list device
              }  // container devices
    
              container management {
                description
                  "Management configuration.";
                leaf type {
                  type identityref {
                    base management;
                  }
                  mandatory true;
                  description
                    "Management type of the connection.";
                }
              }  // container management
    
              container locations {
                description
                  "Location of the site.";
                list location {
                  key "location-id";
                  description
                    "List of locations.";
                  leaf location-id {
                    type string;
                    description "Location ID.";
                  }
    
                  leaf address {
                    type string;
                    description
                      "Address (number and street) of the site.";
                  }
    
                  leaf postal-code {
                    type string;
                    description
                      "Postal code of the site.  The format of 'postal-code'
                     is similar to the 'PC' (postal code) label format
                     defined in RFC 4119.";
                  }
    
                  leaf state {
                    type string;
                    description
                      "State (region) of the site.  This leaf can also be used
                     to describe a region of a country that does not have
                     states.";
                  }
    
                  leaf city {
                    type string;
                    description
                      "City of the site.";
                  }
    
                  leaf country-code {
                    type string;
                    description
                      "Country of the site.  The format of 'country-code' is
                     similar to the 'country' label defined in RFC 4119.";
                  }
                }  // list location
              }  // container locations
    
              container site-diversity {
                if-feature site-diversity;
                description
                  "The type of diversity constraint.";
                container groups {
                  description
                    "Groups to which the site belongs.
                   All site network accesses will inherit those group
                   values.";
                  list group {
                    key "group-id";
                    description
                      "List of group-ids.";
                    leaf group-id {
                      type string;
                      description
                        "The group-id to which the site belongs.";
                    }
                  }  // list group
                }  // container groups
              }  // container site-diversity
    
              container vpn-policies {
                description "VPN policy.";
                list vpn-policy {
                  key "vpn-policy-id";
                  description
                    "List of VPN policies.";
                  leaf vpn-policy-id {
                    type string;
                    description
                      "Unique identifier for the VPN policy.";
                  }
    
                  list entries {
                    key "id";
                    description
                      "List of entries for an export policy.";
                    leaf id {
                      type string;
                      description
                        "Unique identifier for the policy entry.";
                    }
    
                    container filters {
                      description
                        "If a more granular VPN attachment is necessary,
                       filtering can be used.  If used, it permits the
                       splitting of site LANs among multiple VPNs.  The
                       site LAN can be split based on either the LAN tag or
                       the LAN prefix.  If no filter is used, all the LANs
                       will be part of the same VPNs with the same role.";
                      list filter {
                        key "type";
                        ordered-by user;
                        description
                          "List of filters used on the site.  This list can
                         be augmented.";
                        leaf type {
                          type identityref {
                            base vpn-policy-filter-type;
                          }
                          description
                            "Type of VPN policy filter.";
                        }
    
                        leaf-list lan-tag {
                          when
                            "derived-from-or-self(../type, "
                              + "'l2vpn-svc:lan')" {
                            description
                              "Only applies when the VPN policy filter is a
                             LAN tag filter.";
                          }
                          if-feature lan-tag;
                          type uint32;
                          description
                            "List of Ethernet LAN tags to be matched.  An
                           Ethernet LAN tag identifies a particular
                           broadcast domain in a VPN.";
                        }
                      }  // list filter
                    }  // container filters
    
                    list vpn {
                      key "vpn-id";
                      description
                        "List of VPNs with which the LAN is associated.";
                      leaf vpn-id {
                        type leafref {
                          path "/l2vpn-svc/vpn-services/vpn-service/vpn-id";
                        }
                        description
                          "Reference to an L2VPN.";
                      }
    
                      leaf site-role {
                        type identityref {
                          base site-role;
                        }
                        default
                          "any-to-any-role";
                        description
                          "Role of the site in the L2VPN.";
                      }
                    }  // list vpn
                  }  // list entries
                }  // list vpn-policy
              }  // container vpn-policies
    
              container service {
                description
                  "Service parameters on the attachment.";
                uses site-service-qos-profile;
    
                uses site-service-mpls;
              }  // container service
    
              uses site-bum;
    
              uses site-mac-loop-prevention;
    
              uses site-acl;
    
              leaf actual-site-start {
                type yang:date-and-time;
                config false;
                description
                  "This leaf is optional.  It indicates the date and time
                 when the service at a particular site actually started.";
              }
    
              leaf actual-site-stop {
                type yang:date-and-time;
                config false;
                description
                  "This leaf is optional.  It indicates the date and time
                 when the service at a particular site actually stopped.";
              }
    
              leaf bundling-type {
                type identityref {
                  base bundling-type;
                }
                default "one2one-bundling";
                description
                  "Bundling type.  By default, each L2VPN
                 can be associated with only one
                 CE-VLAN, i.e., one-to-one bundling is used.";
              }
    
              leaf default-ce-vlan-id {
                type uint32;
                mandatory true;
                description
                  "Default CE VLAN ID set at the site level.";
              }
    
              container site-network-accesses {
                description
                  "Container of port configurations.";
                list site-network-access {
                  key "network-access-id";
                  description
                    "List of site network accesses.";
                  leaf network-access-id {
                    type string;
                    description
                      "Identifier of network access.";
                  }
    
                  leaf remote-carrier-name {
                    when
                      "derived-from-or-self(../../../site-vpn-flavor,"
                        + "'l2vpn-svc:site-vpn-flavor-nni')" {
                      description
                        "Relevant when the site's VPN flavor is
                       'site-vpn-flavor-nni'.";
                    }
                    type leafref {
                      path "/l2vpn-svc/vpn-profiles/valid-provider-identifiers/remote-carrier-identifier";
                    }
                    description
                      "Remote carrier name.  The 'remote-carrier-name'
                     parameter must be configured only when
                     'site-vpn-flavor' is set to 'site-vpn-flavor-nni'.
                     If it is not set, it indicates that the customer
                     does not know the remote carrier's name
                     beforehand.";
                  }
    
                  leaf type {
                    type identityref {
                      base site-network-access-type;
                    }
                    default "point-to-point";
                    description
                      "Describes the type of connection, e.g.,
                     point-to-point or multipoint.";
                  }
    
                  choice location-flavor {
                    mandatory true;
                    description
                      "Choice of how to describe the site's location.";
                    case location {
                      when
                        "derived-from-or-self(../../management/type, "
                          + "'l2vpn-svc:customer-managed')" {
                        description
                          "Applicable only for a customer-managed device.";
                      }
                      leaf location-reference {
                        type leafref {
                          path "../../../locations/location/location-id";
                        }
                        description
                          "Location of the site-network-access.";
                      }
                    }  // case location
    
                    case device {
                      when
                        "derived-from-or-self(../../management/type, "
                          + "'l2vpn-svc:provider-managed') or "
                          + "derived-from-or-self(../../management/type, "
                          + "'l2vpn-svc:co-managed')" {
                        description
                          "Applicable only for a provider-managed
                         or co-managed device.";
                      }
                      leaf device-reference {
                        type leafref {
                          path "../../../devices/device/device-id";
                        }
                        description
                          "Identifier of the CE to use.";
                      }
                    }  // case device
                  }  // choice location-flavor
    
                  container access-diversity {
                    if-feature site-diversity;
                    description
                      "Diversity parameters.";
                    container groups {
                      description
                        "Groups to which the site or site-network-access
                       belongs.";
                      list group {
                        key "group-id";
                        description
                          "List of group-ids.";
                        leaf group-id {
                          type string;
                          description
                            "Group-id to which the site belongs.";
                        }
                      }  // list group
                    }  // container groups
    
                    container constraints {
                      description
                        "Constraints for placing this site network access.";
                      list constraint {
                        key "constraint-type";
                        description
                          "List of constraints.";
                        leaf constraint-type {
                          type identityref {
                            base placement-diversity;
                          }
                          description
                            "The type of diversity constraint.";
                        }
    
                        container target {
                          description
                            "The constraint will apply against
                           this list of groups.";
                          choice target-flavor {
                            default "id";
                            description
                              "Choice for the group definition.";
                            list group {
                              key "group-id";
                              description
                                "List of groups.";
                              leaf group-id {
                                type string;
                                description
                                  "The constraint will apply against this
                                   particular group-id.";
                              }
                            }  // list group
                            leaf all-other-accesses {
                              type empty;
                              description
                                "The constraint will apply against all other
                                 site network accesses of this site.";
                            }
                            leaf all-other-groups {
                              type empty;
                              description
                                "The constraint will apply against all other
                                 groups the customer is managing.";
                            }
                          }  // choice target-flavor
                        }  // container target
                      }  // list constraint
                    }  // container constraints
                  }  // container access-diversity
    
                  container bearer {
                    description
                      "Bearer-specific parameters.  To be augmented.";
                    container requested-type {
                      if-feature requested-type;
                      description
                        "Container for requested types.";
                      leaf type {
                        type string;
                        description
                          "Type of requested bearer: Ethernet, ATM, Frame
                         Relay, IP Layer 2 transport, Frame Relay Data
                         Link Connection Identifier (DLCI), SONET/SDH,
                         PPP.";
                      }
    
                      leaf strict {
                        type boolean;
                        default "false";
                        description
                          "Defines whether the requested type is a preference
                         or a strict requirement.";
                      }
                    }  // container requested-type
    
                    leaf always-on {
                      if-feature always-on;
                      type boolean;
                      default "true";
                      description
                        "Request for an 'always-on' access type.
                       For example, this could mean no dial-in access
                       type.";
                    }
    
                    leaf bearer-reference {
                      if-feature bearer-reference;
                      type string;
                      description
                        "An internal reference for the SP.";
                    }
                  }  // container bearer
    
                  container connection {
                    description
                      "Container for connection requirements.";
                    leaf encapsulation-type {
                      type identityref {
                        base encapsulation-type;
                      }
                      default "ethernet";
                      description
                        "Encapsulation type.  By default, the
                       encapsulation type is set to 'ethernet'.";
                    }
    
                    leaf eth-inf-type {
                      type identityref {
                        base eth-inf-type;
                      }
                      default "untagged";
                      description
                        "Ethernet interface type.  By default, the
                       Ethernet interface type is set to 'untagged'.";
                    }
    
                    container tagged-interface {
                      description
                        "Container for tagged interfaces.";
                      leaf type {
                        type identityref {
                          base tagged-inf-type;
                        }
                        default
                          "priority-tagged";
                        description
                          "Tagged interface type.  By default,
                         the type of the tagged interface is
                         'priority-tagged'.";
                      }
    
                      container dot1q-vlan-tagged {
                        when
                          "derived-from-or-self(../type, "
                            + "'l2vpn-svc:dot1q')" {
                          description
                            "Only applies when the type of the tagged
                           interface is 'dot1q'.";
                        }
                        if-feature dot1q;
                        description
                          "Tagged interface.";
                        leaf tg-type {
                          type identityref {
                            base tag-type;
                          }
                          default "c-vlan";
                          description
                            "Tag type.  By default, the tag type is
                           'c-vlan'.";
                        }
    
                        leaf cvlan-id {
                          type uint16;
                          mandatory true;
                          description
                            "VLAN identifier.";
                        }
                      }  // container dot1q-vlan-tagged
    
                      container priority-tagged {
                        when
                          "derived-from-or-self(../type, "
                            + "'l2vpn-svc:priority-tagged')" {
                          description
                            "Only applies when the type of the tagged
                           interface is 'priority-tagged'.";
                        }
                        description
                          "Priority tagged.";
                        leaf tag-type {
                          type identityref {
                            base tag-type;
                          }
                          default "c-vlan";
                          description
                            "Tag type.  By default, the tag type is
                           'c-vlan'.";
                        }
                      }  // container priority-tagged
    
                      container qinq {
                        when
                          "derived-from-or-self(../type, "
                            + "'l2vpn-svc:qinq')" {
                          description
                            "Only applies when the type of the tagged
                           interface is 'qinq'.";
                        }
                        if-feature qinq;
                        description "QinQ.";
                        leaf tag-type {
                          type identityref {
                            base tag-type;
                          }
                          default "c-s-vlan";
                          description
                            "Tag type.  By default, the tag type is
                           'c-s-vlan'.";
                        }
    
                        leaf svlan-id {
                          type uint16;
                          mandatory true;
                          description
                            "SVLAN identifier.";
                        }
    
                        leaf cvlan-id {
                          type uint16;
                          mandatory true;
                          description
                            "CVLAN identifier.";
                        }
                      }  // container qinq
    
                      container qinany {
                        when
                          "derived-from-or-self(../type, "
                            + "'l2vpn-svc:qinany')" {
                          description
                            "Only applies when the type of the tagged
                           interface is 'qinany'.";
                        }
                        if-feature qinany;
                        description
                          "Container for QinAny.";
                        leaf tag-type {
                          type identityref {
                            base tag-type;
                          }
                          default "s-vlan";
                          description
                            "Tag type.  By default, the tag type is
                           's-vlan'.";
                        }
    
                        leaf svlan-id {
                          type uint16;
                          mandatory true;
                          description
                            "SVLAN ID.";
                        }
                      }  // container qinany
    
                      container vxlan {
                        when
                          "derived-from-or-self(../type, "
                            + "'l2vpn-svc:vxlan')" {
                          description
                            "Only applies when the type of the tagged
                           interface is 'vxlan'.";
                        }
                        if-feature vxlan;
                        description "QinQ.";
                        leaf vni-id {
                          type uint32;
                          mandatory true;
                          description
                            "VXLAN Network Identifier (VNI).";
                        }
    
                        leaf peer-mode {
                          type identityref {
                            base vxlan-peer-mode;
                          }
                          default "static-mode";
                          description
                            "Specifies the VXLAN access mode.  By default,
                           the peer mode is set to 'static-mode'.";
                        }
    
                        list peer-list {
                          key "peer-ip";
                          description
                            "List of peer IP addresses.";
                          leaf peer-ip {
                            type inet:ip-address;
                            description
                              "Peer IP.";
                          }
                        }  // list peer-list
                      }  // container vxlan
                    }  // container tagged-interface
    
                    container untagged-interface {
                      description
                        "Container of untagged interface attribute
                       configurations.";
                      leaf speed {
                        type uint32;
                        units "mbps";
                        default "10";
                        description
                          "Port speed.";
                      }
    
                      leaf mode {
                        type neg-mode;
                        default "auto-neg";
                        description
                          "Negotiation mode.";
                      }
    
                      leaf phy-mtu {
                        type uint32;
                        units "bytes";
                        description "PHY MTU.";
                      }
    
                      leaf lldp {
                        type boolean;
                        default "false";
                        description
                          "LLDP.  Indicates that LLDP is supported.";
                      }
    
                      container oam-802.3ah-link {
                        if-feature oam-3ah;
                        description
                          "Container for OAM 802.3ah links.";
                        leaf enabled {
                          type boolean;
                          default "false";
                          description
                            "Indicates whether or not to support
                           OAM 802.3ah links.";
                        }
                      }  // container oam-802.3ah-link
    
                      leaf uni-loop-prevention {
                        type boolean;
                        default "false";
                        description
                          "If this leaf is set to 'true', then the port
                         automatically goes down when a physical
                         loopback is detected.";
                      }
                    }  // container untagged-interface
    
                    container lag-interfaces {
                      if-feature lag-interface;
                      description
                        "Container of LAG interface attribute
                       configurations.";
                      list lag-interface {
                        key "index";
                        description
                          "List of LAG interfaces.";
                        leaf index {
                          type string;
                          description
                            "LAG interface index.";
                        }
    
                        container lacp {
                          if-feature lacp;
                          description "LACP.";
                          leaf enabled {
                            type boolean;
                            default "false";
                            description
                              "LACP on/off.  By default, LACP is disabled.";
                          }
    
                          leaf mode {
                            type neg-mode;
                            description
                              "LACP mode.  LACP modes have active mode and
                             passive mode ('false').  'Active mode' means
                             initiating the auto-speed negotiation and
                             trying to form an Ethernet channel with the
                             other end.  'Passive mode' means not initiating
                             the negotiation but responding to LACP packets
                             initiated by the other end (e.g., full duplex
                             or half duplex).";
                          }
    
                          leaf speed {
                            type uint32;
                            units "mbps";
                            default "10";
                            description
                              "LACP speed.  By default, the LACP speed is 10
                             Mbps.";
                          }
    
                          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-priority {
                            type uint16;
                            default "32768";
                            description
                              "Indicates the LACP priority for the system.
                             The range is from 0 to 65535.
                             The default is 32768.";
                          }
    
                          container micro-bfd {
                            if-feature micro-bfd;
                            description
                              "Container of micro-BFD configurations.";
                            leaf enabled {
                              type enumeration {
                                enum "on" {
                                  value 0;
                                  description
                                    "Micro-bfd on.";
                                }
                                enum "off" {
                                  value 1;
                                  description
                                    "Micro-bfd off.";
                                }
                              }
                              default "off";
                              description
                                "Micro-BFD on/off.  By default, micro-BFD
                               is set to 'off'.";
                            }
    
                            leaf interval {
                              type uint32;
                              units
                                "milliseconds";
                              description
                                "BFD interval.";
                            }
    
                            leaf hold-timer {
                              type uint32;
                              units
                                "milliseconds";
                              description
                                "BFD hold timer.";
                            }
                          }  // container micro-bfd
    
                          container bfd {
                            if-feature bfd;
                            description
                              "Container for BFD.";
                            leaf enabled {
                              type boolean;
                              default "false";
                              description
                                "BFD activation.  By default, BFD is not
                               activated.";
                            }
    
                            choice holdtime {
                              default "fixed";
                              description
                                "Choice for the hold-time flavor.";
                              case profile {
                                description
                                  "SP well-known profile.";
                                leaf profile-name {
                                  type leafref {
                                    path "/l2vpn-svc/vpn-profiles/valid-provider-identifiers/bfd-profile-identifier";
                                  }
                                  description
                                    "SP well-known profile.";
                                }
                              }  // case profile
                              leaf fixed-value {
                                type uint32;
                                units
                                  "milliseconds";
                                description
                                  "Expected hold time expressed in
                                   milliseconds.";
                              }
                            }  // choice holdtime
                          }  // container bfd
    
                          container member-links {
                            description
                              "Container of the 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 neg-mode;
                                default
                                  "auto-neg";
                                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 OAM 802.3ah links.";
                                leaf enabled {
                                  type boolean;
                                  default
                                    "false";
                                  description
                                    "Indicates whether OAM 802.3ah links are
                                   supported.";
                                }
                              }  // container oam-802.3ah-link
                            }  // list member-link
                          }  // container member-links
    
                          leaf flow-control {
                            type boolean;
                            default "false";
                            description
                              "Flow control.  Indicates whether flow control
                             is supported.";
                          }
    
                          leaf lldp {
                            type boolean;
                            default "false";
                            description
                              "LLDP.  Indicates whether LLDP is supported.";
                          }
                        }  // container lacp
                      }  // list lag-interface
                    }  // container lag-interfaces
    
                    list cvlan-id-to-svc-map {
                      key "svc-id";
                      description
                        "List of CVLAN-ID-to-L2VPN-service-map
                       configurations.";
                      leaf svc-id {
                        type leafref {
                          path "/l2vpn-svc/vpn-services/vpn-service/vpn-id";
                        }
                        description
                          "VPN service identifier.";
                      }
    
                      list cvlan-id {
                        key "vid";
                        description
                          "List of CVLAN-ID-to-SVC-map configurations.";
                        leaf vid {
                          type uint16;
                          description
                            "CVLAN ID.";
                        }
                      }  // list cvlan-id
                    }  // list cvlan-id-to-svc-map
    
                    container l2cp-control {
                      if-feature l2cp-control;
                      description
                        "Container of L2CP control configurations.";
                      leaf stp-rstp-mstp {
                        type control-mode;
                        description
                          "STP / Rapid STP (RSTP) / Multiple STP (MSTP)
                         protocol type applicable to all sites.";
                      }
    
                      leaf pause {
                        type control-mode;
                        description
                          "Pause protocol type applicable to all sites.";
                      }
    
                      leaf lacp-lamp {
                        type control-mode;
                        description
                          "LACP / Link Aggregation Marker Protocol (LAMP).";
                      }
    
                      leaf link-oam {
                        type control-mode;
                        description "Link OAM.";
                      }
    
                      leaf esmc {
                        type control-mode;
                        description
                          "Ethernet Synchronization Messaging Channel
                         (ESMC).";
                      }
    
                      leaf l2cp-802.1x {
                        type control-mode;
                        description
                          "IEEE 802.1x.";
                      }
    
                      leaf e-lmi {
                        type control-mode;
                        description "E-LMI.";
                      }
    
                      leaf lldp {
                        type boolean;
                        description
                          "LLDP protocol type applicable to all sites.";
                      }
    
                      leaf ptp-peer-delay {
                        type control-mode;
                        description
                          "Precision Time Protocol (PTP) peer delay.";
                      }
    
                      leaf garp-mrp {
                        type control-mode;
                        description "GARP/MRP.";
                      }
                    }  // container l2cp-control
    
                    container oam {
                      if-feature ethernet-oam;
                      description
                        "Container for Ethernet Service OAM.";
                      leaf md-name {
                        type string;
                        mandatory true;
                        description
                          "Maintenance domain name.";
                      }
    
                      leaf md-level {
                        type uint16 {
                          range "0..255";
                        }
                        mandatory true;
                        description
                          "Maintenance domain level.  The level may be
                         restricted in certain protocols (e.g.,
                         protocols in Layer 0 to Layer 7).";
                      }
    
                      list cfm-8021-ag {
                        if-feature cfm;
                        key "maid";
                        description
                          "List of 802.1ag CFM attributes.";
                        leaf maid {
                          type string;
                          mandatory true;
                          description
                            "Identifies a Maintenance Association (MA).";
                        }
    
                        leaf mep-id {
                          type uint32;
                          description
                            "Local Maintenance Entity Group End Point (MEP)
                           ID.  The non-existence of this leaf means
                           that no defects are to be reported.";
                        }
    
                        leaf mep-level {
                          type uint32;
                          description
                            "Defines the MEP level.  The non-existence of this
                           leaf means that no defects are to be reported.";
                        }
    
                        leaf mep-up-down {
                          type enumeration {
                            enum "up" {
                              value 0;
                              description
                                "MEP up.";
                            }
                            enum "down" {
                              value 1;
                              description
                                "MEP down.";
                            }
                          }
                          default "up";
                          description
                            "MEP up/down.  By default, MEP up is used.
                           The non-existence of this leaf means that
                           no defects are to be reported.";
                        }
    
                        leaf remote-mep-id {
                          type uint32;
                          description
                            "Remote MEP ID.  The non-existence of this leaf
                           means that no defects are to be reported.";
                        }
    
                        leaf cos-for-cfm-pdus {
                          type uint32;
                          description
                            "CoS for CFM PDUs.  The non-existence of this leaf
                           means that no defects are to be reported.";
                        }
    
                        leaf ccm-interval {
                          type uint32;
                          units "milliseconds";
                          default "10000";
                          description
                            "CCM interval.  By default, the CCM interval is
                           10,000 milliseconds (10 seconds).";
                        }
    
                        leaf ccm-holdtime {
                          type uint32;
                          units "milliseconds";
                          default "35000";
                          description
                            "CCM hold time.  By default, the CCM hold time
                           is 3.5 times the CCM interval.";
                        }
    
                        leaf alarm-priority-defect {
                          type identityref {
                            base fault-alarm-defect-type;
                          }
                          default
                            "remote-invalid-ccm";
                          description
                            "The lowest-priority defect that is
                           allowed to generate a fault alarm.  By default,
                           'fault-alarm-defect-type' is set to
                           'remote-invalid-ccm'.  The non-existence of
                           this leaf means that no defects are
                           to be reported.";
                        }
    
                        leaf ccm-p-bits-pri {
                          type ccm-priority-type;
                          description
                            "The priority parameter for CCMs transmitted by
                           the MEP.  The non-existence of this leaf means
                           that no defects are to be reported.";
                        }
                      }  // list cfm-8021-ag
    
                      list y-1731 {
                        if-feature y-1731;
                        key "maid";
                        description
                          "List of configured Y-1731 instances.";
                        leaf maid {
                          type string;
                          mandatory true;
                          description
                            "Identifies an MA.";
                        }
    
                        leaf mep-id {
                          type uint32;
                          description
                            "Local MEP ID.  The non-existence of this leaf
                           means that no measurements are to be reported.";
                        }
    
                        leaf type {
                          type identityref {
                            base pm-type;
                          }
                          default "delay";
                          description
                            "Performance-monitoring types.  By default, the
                           performance-monitoring type is set to 'delay'.
                           The non-existence of this leaf means that no
                           measurements are to be reported.";
                        }
    
                        leaf remote-mep-id {
                          type uint32;
                          description
                            "Remote MEP ID.  The non-existence of this
                           leaf means that no measurements are to be
                           reported.";
                        }
    
                        leaf message-period {
                          type uint32;
                          units "milliseconds";
                          default "10000";
                          description
                            "Defines the interval between Y.1731
                           performance-monitoring messages.  The message
                           period is expressed in milliseconds.";
                        }
    
                        leaf measurement-interval {
                          type uint32;
                          units "seconds";
                          description
                            "Specifies the measurement interval for
                           statistics.  The measurement interval is
                           expressed in seconds.";
                        }
    
                        leaf cos {
                          type uint32;
                          description
                            "CoS.  The non-existence of this leaf means that
                           no measurements are to be reported.";
                        }
    
                        leaf loss-measurement {
                          type boolean;
                          default "false";
                          description
                            "Indicates whether or not to enable loss
                           measurement.  By default, loss
                           measurement is not enabled.";
                        }
    
                        leaf synthetic-loss-measurement {
                          type boolean;
                          default "false";
                          description
                            "Indicates whether or not to enable synthetic loss
                           measurement.  By default, synthetic loss
                           measurement is not enabled.";
                        }
    
                        container delay-measurement {
                          description
                            "Container for delay measurement.";
                          leaf enable-dm {
                            type boolean;
                            default "false";
                            description
                              "Indicates whether or not to enable delay
                             measurement.  By default, delay measurement
                             is not enabled.";
                          }
    
                          leaf two-way {
                            type boolean;
                            default "false";
                            description
                              "Indicates whether delay measurement is two-way
                             ('true') or one-way ('false').  By default,
                             one-way measurement is enabled.";
                          }
                        }  // container delay-measurement
    
                        leaf frame-size {
                          type uint32;
                          units "bytes";
                          description
                            "Frame size.  The non-existence of this leaf
                           means that no measurements are to be reported.";
                        }
    
                        leaf session-type {
                          type enumeration {
                            enum "proactive" {
                              value 0;
                              description
                                "Proactive mode.";
                            }
                            enum "on-demand" {
                              value 1;
                              description
                                "On-demand mode.";
                            }
                          }
                          default "on-demand";
                          description
                            "Session type.  By default, the session type
                           is 'on-demand'.  The non-existence of this
                           leaf means that no measurements are to be
                           reported.";
                        }
                      }  // list y-1731
                    }  // container oam
                  }  // container connection
    
                  container availability {
                    description
                      "Container of available optional configurations.";
                    leaf access-priority {
                      type uint32;
                      default "100";
                      description
                        "Access priority.  The higher the access-priority
                       value, the higher the preference will be for the
                       access in question.";
                    }
    
                    choice redundancy-mode {
                      description
                        "Redundancy mode choice.";
                      case single-active {
                        description
                          "In single-active mode, only one node forwards
                         traffic to and from the Ethernet segment.";
                        leaf single-active {
                          type empty;
                          description
                            "Single-active mode.";
                        }
                      }  // case single-active
    
                      case all-active {
                        description
                          "In all-active mode, all nodes can forward
                         traffic.";
                        leaf all-active {
                          type empty;
                          description
                            "All-active mode.";
                        }
                      }  // case all-active
                    }  // choice redundancy-mode
                  }  // container availability
    
                  container vpn-attachment {
                    description
                      "Defines the VPN attachment of a site.";
                    choice attachment-flavor {
                      mandatory true;
                      description
                        "Choice for the VPN attachment flavor.";
                      case vpn-id {
                        leaf vpn-id {
                          type leafref {
                            path "/l2vpn-svc/vpn-services/vpn-service/vpn-id";
                          }
                          description
                            "Reference to an L2VPN.  Referencing a vpn-id
                           provides an easy way to attach a particular
                           logical access to a VPN.  In this case,
                           the vpn-id must be configured.";
                        }
    
                        leaf site-role {
                          type identityref {
                            base site-role;
                          }
                          default
                            "any-to-any-role";
                          description
                            "Role of the site in the L2VPN.  When referencing
                           a vpn-id, the site-role setting must be added to
                           express the role of the site in the target VPN
                           service topology.";
                        }
                      }  // case vpn-id
                      leaf vpn-policy-id {
                        type leafref {
                          path "../../../../vpn-policies/vpn-policy/vpn-policy-id";
                        }
                        description
                          "Reference to a VPN policy.";
                      }
                    }  // choice attachment-flavor
                  }  // container vpn-attachment
    
                  container service {
                    description
                      "Container for services.";
                    container svc-bandwidth {
                      if-feature input-bw;
                      description
                        "From the customer site's perspective, the service
                       input/output bandwidth of the connection or
                       download/upload bandwidth from the SP/site
                       to the site/SP.";
                      list bandwidth {
                        key "direction type";
                        description
                          "List of bandwidth values (e.g., per CoS,
                         per vpn-id).";
                        leaf direction {
                          type identityref {
                            base bw-direction;
                          }
                          description
                            "Indicates the bandwidth direction.  It can be
                           the bandwidth download direction from the SP to
                           the site or the bandwidth upload direction from
                           the site to the SP.";
                        }
    
                        leaf type {
                          type identityref {
                            base bw-type;
                          }
                          description
                            "Bandwidth type.  By default, the bandwidth type
                           is set to 'bw-per-cos'.";
                        }
    
                        leaf cos-id {
                          when
                            "derived-from-or-self(../type, "
                              + "'l2vpn-svc:bw-per-cos')" {
                            description
                              "Relevant when the bandwidth type is set to
                             'bw-per-cos'.";
                          }
                          type uint8;
                          description
                            "Identifier of the CoS, indicated by DSCP or a
                           CE-VLAN CoS (802.1p) value in the service frame.
                           If the bandwidth type is set to 'bw-per-cos',
                           the CoS ID MUST also be specified.";
                        }
    
                        leaf vpn-id {
                          when
                            "derived-from-or-self(../type, "
                              + "'l2vpn-svc:bw-per-svc')" {
                            description
                              "Relevant when the bandwidth type is
                             set as bandwidth per VPN service.";
                          }
                          type svc-id;
                          description
                            "Identifies the target VPN.  If the bandwidth
                           type is set as bandwidth per VPN service, the
                           vpn-id MUST be specified.";
                        }
    
                        leaf cir {
                          type uint64;
                          units "bps";
                          mandatory true;
                          description
                            "Committed Information Rate.  The maximum number
                           of bits that a port can receive or send over
                           an interface in one second.";
                        }
    
                        leaf cbs {
                          type uint64;
                          units "bps";
                          mandatory true;
                          description
                            "Committed Burst Size (CBS).  Controls the bursty
                           nature of the traffic.  Traffic that does not
                           use the configured Committed Information Rate
                           (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 that is not subject to an SLA.
                           The traffic rate can be limited by the EIR.";
                        }
    
                        leaf ebs {
                          type uint64;
                          units "bps";
                          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, i.e., maximum frame
                           delivery allowed.  It is equal to or less
                           than the sum of the CIR and the EIR.";
                        }
    
                        leaf pbs {
                          type uint64;
                          units "bps";
                          description
                            "Peak Burst Size.  It is measured in bytes per
                           second.";
                        }
                      }  // list bandwidth
                    }  // container svc-bandwidth
    
                    leaf svc-mtu {
                      type uint16;
                      units "bytes";
                      mandatory true;
                      description
                        "SVC MTU.  It is also known as the maximum
                       transmission unit or maximum frame size.  When
                       a frame is larger than the MTU, it is broken
                       down, or fragmented, into smaller pieces by
                       the network protocol to accommodate the MTU
                       of the network.  If CsC is enabled,
                       the requested svc-mtu leaf will refer to the
                       MPLS MTU and not to the link MTU.";
                    }
    
                    uses site-service-qos-profile;
    
                    uses site-service-mpls;
                  }  // container service
    
                  uses site-bum;
    
                  uses site-mac-loop-prevention;
    
                  uses site-acl;
    
                  container mac-addr-limit {
                    if-feature mac-addr-limit;
                    description
                      "Container of MAC address limit configurations.";
                    leaf limit-number {
                      type uint16;
                      default "2";
                      description
                        "Maximum number of MAC addresses learned from
                       the subscriber for a single service instance.
                       The default allowed maximum number of MAC
                       addresses is 2.";
                    }
    
                    leaf time-interval {
                      type uint32;
                      units "seconds";
                      default "300";
                      description
                        "The aging time of the MAC address.  By default,
                       the aging time is set to 300 seconds.";
                    }
    
                    leaf action {
                      type identityref {
                        base mac-action;
                      }
                      default "warning";
                      description
                        "Specifies the action taken when the upper limit is
                       exceeded: drop the packet, flood the packet, or
                       simply send a warning log message.  By default,
                       the action is set to 'warning'.";
                    }
                  }  // container mac-addr-limit
                }  // list site-network-access
              }  // container site-network-accesses
            }  // list site
          }  // container sites
        }  // container l2vpn-svc
      }  // module ietf-l2vpn-svc
    

© 2023 YumaWorks, Inc. All rights reserved.