junos-conf-class-of-service@2019-01-01.yang

/*
 * Copyright (c) 2019 Juniper Networks, Inc.
 * All rights reserved.
 */
 module junos-conf-class-of-service {
   namespace "http://yang.juniper.net/junos/conf/class-of-service";

   prefix jc-class-of-service;

   import junos-common-types {
     prefix jt;
   }

   import junos-conf-root {
     prefix jc;
   }

   organization "Juniper Networks, Inc.";

   contact "yang-support@juniper.net";

   description "Junos class-of-service configuration module";

   revision 2019-01-01 {
     description "Junos: 18.4R3.3";
   }

   augment /jc:configuration {
     uses class-of-service-group;
   }
   augment /jc:configuration/jc:groups {
     uses class-of-service-group;
   }
   grouping class-of-service-group {
     container class-of-service {
       description "Class-of-service configuration";
       uses juniper-class-of-service-options;
     }
   }
   grouping juniper-class-of-service-options {
     uses apply-advanced;
     container classifiers {
       description "Classify incoming packets based on code point value";
       uses apply-advanced;
       list dscp {
         key name;
         ordered-by user;
         description "Differentiated Services code point classifier";
         leaf name {
           description "Classifier name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this classifier in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Define a classification of code point aliases";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Classify code points to a loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Code points to classify to loss priority low";
                 }
                 enum "high" {
                   description "Code points to classify to loss priority high";
                 }
                 enum "medium-low" {
                   description "Code points to classify to loss priority medium-low";
                 }
                 enum "medium-high" {
                   description "Code points to classify to loss priority medium-high";
                 }
               }
             }
             leaf-list code-points {
               ordered-by user;
               description "List of code point aliases and/or bit strings";
               type string;
             }
           }
         }
       }
       list dscp-ipv6 {
         key name;
         ordered-by user;
         description "Differentiated Services code point classifier IPv6";
         leaf name {
           description "Classifier name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this classifier in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Define a classification of code point aliases";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Classify code points to a loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Code points to classify to loss priority low";
                 }
                 enum "high" {
                   description "Code points to classify to loss priority high";
                 }
                 enum "medium-low" {
                   description "Code points to classify to loss priority medium-low";
                 }
                 enum "medium-high" {
                   description "Code points to classify to loss priority medium-high";
                 }
               }
             }
             leaf-list code-points {
               ordered-by user;
               description "List of code point aliases and/or bit strings";
               type string;
             }
           }
         }
       }
       list exp {
         key name;
         ordered-by user;
         description "MPLS EXP classifier";
         leaf name {
           description "Classifier name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this classifier in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Define a classification of code point aliases";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Classify code points to a loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Code points to classify to loss priority low";
                 }
                 enum "high" {
                   description "Code points to classify to loss priority high";
                 }
                 enum "medium-low" {
                   description "Code points to classify to loss priority medium-low";
                 }
                 enum "medium-high" {
                   description "Code points to classify to loss priority medium-high";
                 }
               }
             }
             leaf-list code-points {
               ordered-by user;
               description "List of code point aliases and/or bit strings";
               type string;
             }
           }
         }
       }
       list ieee-802.1 {
         key name;
         ordered-by user;
         description "IEEE-802.1 classifier";
         leaf name {
           description "Classifier name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this classifier in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Define a classification of code point aliases";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Classify code points to a loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Code points to classify to loss priority low";
                 }
                 enum "high" {
                   description "Code points to classify to loss priority high";
                 }
                 enum "medium-low" {
                   description "Code points to classify to loss priority medium-low";
                 }
                 enum "medium-high" {
                   description "Code points to classify to loss priority medium-high";
                 }
               }
             }
             leaf-list code-points {
               ordered-by user;
               description "List of code point aliases and/or bit strings";
               type string;
             }
           }
         }
       }
       list inet-precedence {
         key name;
         ordered-by user;
         description "IPv4 precedence classifier";
         leaf name {
           description "Classifier name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this classifier in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Define a classification of code point aliases";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Classify code points to a loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Code points to classify to loss priority low";
                 }
                 enum "high" {
                   description "Code points to classify to loss priority high";
                 }
                 enum "medium-low" {
                   description "Code points to classify to loss priority medium-low";
                 }
                 enum "medium-high" {
                   description "Code points to classify to loss priority medium-high";
                 }
               }
             }
             leaf-list code-points {
               ordered-by user;
               description "List of code point aliases and/or bit strings";
               type string;
             }
           }
         }
       }
       list ieee-802.1ad {
         key name;
         ordered-by user;
         description "IEEE-802.1ad (DEI) classifier";
         leaf name {
           description "Classifier name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this classifier in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Define a classification of code point aliases";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Classify code points to a loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Code points to classify to loss priority low";
                 }
                 enum "high" {
                   description "Code points to classify to loss priority high";
                 }
                 enum "medium-low" {
                   description "Code points to classify to loss priority medium-low";
                 }
                 enum "medium-high" {
                   description "Code points to classify to loss priority medium-high";
                 }
               }
             }
             leaf-list code-points {
               ordered-by user;
               description "List of code point aliases and/or bit strings";
               type string;
             }
           }
         }
       }
     }
     container traffic-class-map {
       description "Packet input priority map based on incoming packets code point";
       uses apply-advanced;
       list inet-precedence {
         key name;
         ordered-by user;
         description "IPv4 precedence traffic-class-map";
         leaf name {
           description "Traffic-class-map name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list traffic-class {
           key name;
           ordered-by user;
           description "Map code points to a input packet priority";
           leaf name {
             type enumeration {
               enum "real-time" {
                 description "Code points map to traffic-class real-time";
               }
               enum "network-control" {
                 description "Code points map to traffic-class network-control";
               }
               enum "best-effort" {
                 description "Code points map to traffic-class best-effort";
               }
             }
           }
           leaf-list code-points {
             ordered-by user;
             description "List of code point aliases and/or bit strings";
             type string;
           }
         }
       }
       list dscp {
         key name;
         ordered-by user;
         description "Differentiated Services code point traffic-class-map";
         leaf name {
           description "Traffic-class-map name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list traffic-class {
           key name;
           ordered-by user;
           description "Map code points to a input packet priority";
           leaf name {
             type enumeration {
               enum "real-time" {
                 description "Code points map to traffic-class real-time";
               }
               enum "network-control" {
                 description "Code points map to traffic-class network-control";
               }
               enum "best-effort" {
                 description "Code points map to traffic-class best-effort";
               }
             }
           }
           leaf-list code-points {
             ordered-by user;
             description "List of code point aliases and/or bit strings";
             type string;
           }
         }
       }
       list exp {
         key name;
         ordered-by user;
         description "MPLS EXP traffic-class-map";
         leaf name {
           description "Traffic-class-map name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list traffic-class {
           key name;
           ordered-by user;
           description "Map code points to a input packet priority";
           leaf name {
             type enumeration {
               enum "real-time" {
                 description "Code points map to traffic-class real-time";
               }
               enum "network-control" {
                 description "Code points map to traffic-class network-control";
               }
               enum "best-effort" {
                 description "Code points map to traffic-class best-effort";
               }
             }
           }
           leaf-list code-points {
             ordered-by user;
             description "List of code point aliases and/or bit strings";
             type string;
           }
         }
       }
       list ieee-802.1 {
         key name;
         ordered-by user;
         description "IEEE-802.1 traffic-class-map";
         leaf name {
           description "Traffic-class-map name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list traffic-class {
           key name;
           ordered-by user;
           description "Map code points to a input packet priority";
           leaf name {
             type enumeration {
               enum "real-time" {
                 description "Code points map to traffic-class real-time";
               }
               enum "network-control" {
                 description "Code points map to traffic-class network-control";
               }
               enum "best-effort" {
                 description "Code points map to traffic-class best-effort";
               }
             }
           }
           leaf-list code-points {
             ordered-by user;
             description "List of code point aliases and/or bit strings";
             type string;
           }
         }
       }
       list ieee-802.1ad {
         key name;
         ordered-by user;
         description "IEEE-802.1ad (DEI) traffic-class-map";
         leaf name {
           description "Traffic-class-map name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list traffic-class {
           key name;
           ordered-by user;
           description "Map code points to a input packet priority";
           leaf name {
             type enumeration {
               enum "real-time" {
                 description "Code points map to traffic-class real-time";
               }
               enum "network-control" {
                 description "Code points map to traffic-class network-control";
               }
               enum "best-effort" {
                 description "Code points map to traffic-class best-effort";
               }
             }
           }
           leaf-list code-points {
             ordered-by user;
             description "List of code point aliases and/or bit strings";
             type string;
           }
         }
       }
     }
     list policy-map {
       key name;
       ordered-by user;
       description "Policy-map describing the packet marking rule";
       max-elements 65535;
       leaf name {
         description "Policy-map name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list inet-precedence {
         key name;
         ordered-by user;
         description "IPv4 INET-Precedence Policy-map code point";
         leaf name {
           description "Optional flag to specify marking behavior";
           type enumeration {
             enum "proto-ip" {
               description "Default marking behavior";
             }
             enum "proto-mpls" {
               description "Enable IP header marking for IP->MPLS packet";
             }
           }
         }
         leaf code-point {
           description "List of code point aliases and/or bit strings";
           type string {
           }
         }
       }
       list dscp {
         key name;
         ordered-by user;
         description "IPv4 Differentiated Services Policy-map code point";
         leaf name {
           description "Optional flag to specify marking behavior";
           type enumeration {
             enum "proto-ip" {
               description "Default marking behavior";
             }
             enum "proto-mpls" {
               description "Enable IP header marking for IP->MPLS packet";
             }
           }
         }
         leaf code-point {
           description "List of code point aliases and/or bit strings";
           type string {
           }
         }
       }
       list dscp-ipv6 {
         key name;
         ordered-by user;
         description "IPv6 Differentiated Services Policy-map code point";
         leaf name {
           description "Optional flag to specify marking behavior";
           type enumeration {
             enum "proto-ip" {
               description "Default marking behavior";
             }
             enum "proto-mpls" {
               description "Enable IP header marking for IP->MPLS packet";
             }
           }
         }
         leaf code-point {
           description "List of code point aliases and/or bit strings";
           type string {
           }
         }
       }
       list exp {
         key name;
         ordered-by user;
         description "MPLS EXP Policy-map code point";
         leaf name {
           description "Optional flag to specify marking behavior";
           type enumeration {
             enum "all-label" {
               description "Default marking behavior";
             }
             enum "outer-label" {
               description "Marking on only outer MPLS label";
             }
           }
         }
         leaf code-point {
           description "List of code point aliases and/or bit strings";
           type string {
           }
         }
       }
       list ieee-802.1 {
         key name;
         ordered-by user;
         description "IEEE-802.1 Policy-map code point";
         leaf name {
           description "Optional flag to specify marking behavior";
           type enumeration {
             enum "outer" {
               description "Marking on outer VLAN tag";
             }
             enum "outer-and-inner" {
               description "Marking on both outer and inner VLAN tag";
             }
           }
         }
         leaf code-point {
           description "List of code point aliases and/or bit strings";
           type string {
           }
         }
       }
       list ieee-802.1ad {
         key name;
         ordered-by user;
         description "IEEE-802.1ad Policy-map code point";
         leaf name {
           description "Optional flag to specify marking behavior";
           type enumeration {
             enum "outer" {
               description "Marking on outer VLAN tag";
             }
             enum "outer-and-inner" {
               description "Marking on both outer and inner VLAN tag";
             }
           }
         }
         leaf code-point {
           description "IEEE-802.1ad (DEI) Policy-map code point";
           type string {
           }
         }
       }
     }
     list forwarding-class-map {
       key name;
       ordered-by user;
       description "Map forwarding class to queue number for interfaces";
       leaf name {
         description "Interface specific forwarding class name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list class {
         key name;
         ordered-by user;
         description "Forwarding class";
         leaf name {
           description "Name of forwarding class";
           type string {
             length "1 .. 64";
           }
         }
         leaf queue-num {
           description "Queue number";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32;
           }
         }
         leaf restricted-queue {
           description "Restricted queue number";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 3";
             }
           }
         }
       }
     }
     container loss-priority-maps {
       description "Map loss priority of incoming packets based on code point value";
       uses apply-advanced;
       list frame-relay-de {
         key name;
         ordered-by user;
         description "Frame relay discard eligible bit loss priority map";
         leaf name {
           description "Loss priority map name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list loss-priority {
           key name;
           ordered-by user;
           description "Map code points to a loss priority";
           leaf name {
             type enumeration {
               enum "low" {
                 description "Code points to classify to low loss priority";
               }
               enum "high" {
                 description "Code points to classify to high loss priority";
               }
               enum "medium-low" {
                 description "Code points to classify to medium-low loss priority";
               }
               enum "medium-high" {
                 description "Code points to classify to medium-high loss priority";
               }
             }
           }
           leaf-list code-points {
             ordered-by user;
             description "List of bit strings";
             type string;
           }
         }
       }
     }
     container loss-priority-rewrites {
       description "Rewrite code point of outgoing packet based on loss priority";
       uses apply-advanced;
       list frame-relay-de {
         key name;
         ordered-by user;
         description "Frame relay discard eligible bit loss priority rewrite";
         leaf name {
           description "Loss priority rewrite name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list loss-priority {
           key name;
           ordered-by user;
           description "Code point marking based on loss priority";
           leaf name {
             type enumeration {
               enum "low" {
                 description "Marking when loss priority is low";
               }
               enum "high" {
                 description "Marking when loss priority is high";
               }
               enum "medium-low" {
                 description "Marking when loss priority is medium-low";
               }
               enum "medium-high" {
                 description "Marking when loss priority is medium-high";
               }
             }
           }
           leaf code-point {
             description "Code point aliases or bit string";
             type string {
             }
           }
         }
       }
     }
     container code-point-aliases {
       description "Mapping of code point aliases to bit strings";
       uses apply-advanced;
       list dscp {
         key name;
         ordered-by user;
         description "Differentiated Services code point aliases";
         leaf name {
           description "DSCP alias name";
           type string {
           }
         }
         leaf bits {
           description "DSCP 6-bit pattern";
           type string {
           }
         }
       }
       list dscp-ipv6 {
         key name;
         ordered-by user;
         description "Differentiated Services code point aliases IPv6";
         leaf name {
           description "DSCP IPv6 alias name";
           type string {
           }
         }
         leaf bits {
           description "DSCP 6-bit pattern";
           type string {
           }
         }
       }
       list exp {
         key name;
         ordered-by user;
         description "MPLS EXP code point aliases";
         leaf name {
           description "EXP alias name";
           type string {
           }
         }
         leaf bits {
           description "EXP 3-bit pattern";
           type string {
           }
         }
       }
       list ieee-802.1 {
         key name;
         ordered-by user;
         description "IEEE-802.1 code point aliases";
         leaf name {
           description "IEEE-802.1 alias name";
           type string {
           }
         }
         leaf bits {
           description "IEEE-802.1 3-bit pattern";
           type string {
           }
         }
       }
       list inet-precedence {
         key name;
         ordered-by user;
         description "IPv4 precedence code point aliases";
         leaf name {
           description "IPv4 precedence alias name";
           type string {
           }
         }
         leaf bits {
           description "IPv4 precedence 3-bit pattern";
           type string {
           }
         }
       }
       list ieee-802.1ad {
         key name;
         ordered-by user;
         description "IEEE-802.1ad (DEI) code point aliases";
         leaf name {
           description "IEEE-802.1ad (DEI) alias name";
           type string {
           }
         }
         leaf bits {
           description "IEEE-802.1ad (DEI) 4-bit pattern";
           type string {
           }
         }
       }
       list inet6-precedence {
         key name;
         ordered-by user;
         description "IPv6 precedence code point aliases";
         leaf name {
           description "IPv6 precedence alias name";
           type string {
           }
         }
         leaf bits {
           description "IPv6 precedence 3-bit pattern";
           type string {
           }
         }
       }
     }
     container translation-table {
       description "Translation table";
       uses apply-advanced;
       list to-802.1p-from-dscp {
         key name;
         ordered-by user;
         description "DSCP to 802.1 translation table";
         leaf name {
           description "Translation table name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list to-code-point {
           key name;
           ordered-by user;
           description "IEEE 802.1 code point";
           leaf name {
             description "IEEE 802.1 code point";
             type string {
             }
           }
           leaf-list from-code-points {
             ordered-by user;
             description "DSCP code point";
             type string;
           }
         }
       }
       list to-inet-precedence-from-inet-precedence {
         key name;
         ordered-by user;
         description "INET PRECEDENCE to INET PRECEDENCE translation table";
         leaf name {
           description "Translation table name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list to-code-point {
           key name;
           ordered-by user;
           description "INET PRECEDENCE code point";
           leaf name {
             description "INET PRECEDENCE code point";
             type string {
             }
           }
           leaf-list from-code-points {
             ordered-by user;
             description "INET PRECEDENCE code point";
             type union {
               type string {
                 pattern "\*";
               }
               type string;
             }
           }
         }
       }
       list to-dscp-from-dscp {
         key name;
         ordered-by user;
         description "DSCP to DSCP translation table";
         leaf name {
           description "Translation table name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list to-code-point {
           key name;
           ordered-by user;
           description "DSCP code point";
           leaf name {
             description "DSCP code point";
             type string {
             }
           }
           leaf-list from-code-points {
             ordered-by user;
             description "DSCP code point";
             type union {
               type string {
                 pattern "\*";
               }
               type string;
             }
           }
         }
       }
       list to-dscp-ipv6-from-dscp-ipv6 {
         key name;
         ordered-by user;
         description "DSCP-IPV6 to DSCP-IPV6 translation table";
         leaf name {
           description "Translation table name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list to-code-point {
           key name;
           ordered-by user;
           description "DSCP-IPV6 code point";
           leaf name {
             description "DSCP-IPV6 code point";
             type string {
             }
           }
           leaf-list from-code-points {
             ordered-by user;
             description "DSCP-IPV6 code point";
             type union {
               type string {
                 pattern "\*";
               }
               type string;
             }
           }
         }
       }
       list to-exp-from-exp {
         key name;
         ordered-by user;
         description "EXP to EXP translation table";
         leaf name {
           description "Translation table name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         list to-code-point {
           key name;
           ordered-by user;
           description "EXP code point";
           leaf name {
             description "EXP code point";
             type string {
             }
           }
           leaf-list from-code-points {
             ordered-by user;
             description "EXP code point";
             type union {
               type string {
                 pattern "\*";
               }
               type string;
             }
           }
         }
       }
     }
     container host-outbound-traffic {
       description "Classify and mark host traffic to forwarding engine";
       uses apply-advanced;
       leaf forwarding-class {
         description "Classification of host traffic to forwarding engine";
         type string {
           length "1 .. 64";
         }
       }
       leaf dscp-code-point {
         description "Static DSCP code point of egress host traffic";
         type string {
         }
       }
       leaf override-firewall {
         description "Override firewall filter actions for RE generated traffic";
         type empty;
       }
       container translation-table {
         description "Translation table for host outbound packets";
         leaf to-802.1p-from-dscp {
           description "DSCP to 802.1 translation table";
           type string {
             length "1 .. 64";
           }
         }
       }
       container tcp {
         presence "enable tcp";
         description "Settings for host outbound TCP packets";
         uses apply-advanced;
         leaf raise-internet-control-priority {
           description "Place packets with IP Precedence set to Internet control into Q3 (network-control)";
           type empty;
         }
       }
       container ieee-802.1 {
         presence "enable ieee-802.1";
         description "Mark IEEE 802.1p for host output traffic";
         uses apply-advanced;
         leaf rewrite-rules {
           description "Mark IEEE 802.1p for host outbound traffic using rewrite-rules";
           type empty;
         }
         leaf default {
           description "Mark IEEE 802.1p for host outbound traffic default value";
           type string {
           }
         }
       }
       container protocol {
         description "Settings for specific host outbound protocol packets";
         uses apply-advanced;
         container isis-over-gre {
           description "Settings for ISIS over GRE packets";
           uses apply-advanced;
           leaf dscp-code-point {
             description "Static DSCP code point of egress host traffic";
             type string {
             }
           }
         }
       }
     }
     list drop-profiles {
       key name;
       ordered-by user;
       description "Random Early Drop (RED) data point map";
       leaf name {
         description "Drop profile name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list fill-level {
         key name;
         ordered-by user;
         description "Fill-level value of data point";
         leaf name {
           description "Percentage the queue is full";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 100";
             }
           }
         }
         leaf drop-probability {
           description "Probability packet will be dropped";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 100";
             }
           }
         }
       }
       container interpolate {
         description "Data points interpolated";
         uses apply-advanced;
         leaf-list fill-level {
           ordered-by user;
           description "Data points for queue full percentage";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 100";
             }
           }
         }
         leaf-list drop-probability {
           ordered-by user;
           description "Data points for packet drop probability";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 100";
             }
           }
         }
       }
     }
     list adaptive-shapers {
       key name;
       ordered-by user;
       description "Define the list of trigger types and associated rates";
       leaf name {
         description "Adaptive shaper name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list trigger {
         key name;
         ordered-by user;
         description "List of trigger types";
         leaf name {
           type enumeration {
             enum "becn" {
               description "Backward explicit congestion notification";
             }
           }
         }
         container shaping-rate {
           description "Shaping rate for the trigger";
           choice rate-choice {
             case case_1 {
               leaf absolute-rate {
                 description "Shaping rate as an absolute rate";
                 units "bits per second";
                 type string;
               }
             }
             case case_2 {
               leaf percent {
                 description "Shaping rate as a percentage";
                 type union {
                   type string {
                     pattern "<.*>|$.*";
                   }
                   type uint32 {
                     range "1 .. 100";
                   }
                 }
               }
             }
           }
         }
       }
     }
     list virtual-channels {
       key name;
       ordered-by user;
       description "Define the list of virtual channels";
       leaf name {
         description "Virtual channel name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
     }
     list virtual-channel-groups {
       key name;
       ordered-by user;
       description "Define list of virtual channel groups";
       leaf name {
         description "Virtual channel group name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list channel {
         key name;
         ordered-by user;
         description "Configure virtual channel for this group";
         leaf name {
           description "Virtual channel group name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf scheduler-map {
           description "Scheduler map applied to this virtual channel";
           type string {
             length "1 .. 64";
           }
         }
         container shaping-rate {
           description "Shaping rate for the trigger";
           choice rate-choice {
             case case_1 {
               leaf absolute-rate {
                 description "Adaptive shaping rate as an absolute rate";
                 units "bits per second";
                 type string;
               }
             }
             case case_2 {
               leaf percent {
                 description "Adaptive shaping rate as a percentage";
                 type union {
                   type string {
                     pattern "<.*>|$.*";
                   }
                   type uint32 {
                     range "1 .. 100";
                   }
                 }
               }
             }
           }
         }
         leaf default {
           description "Default virtual channel";
           type empty;
         }
       }
     }
     leaf copy-plp-all {
       description "Turn on loss-precedence copying including IP multicast";
       type empty;
     }
     leaf tri-color {
       description "Enable tricolor marking";
       type empty;
     }
     leaf non-strict-priority-scheduling {
       description "Enable non-strict-priority scheduling";
       type empty;
     }
     container shared-buffer {
       description "Shared buffer configuration";
       uses apply-advanced;
       leaf percent {
         description "Percentage of shared buffer to be used";
         type union {
           type string {
             pattern "<.*>|$.*";
           }
           type uint32 {
             range "5 .. 100";
           }
         }
       }
     }
     container forwarding-classes {
       description "One or more mappings of forwarding class to queue number";
       uses apply-advanced;
       list class {
         key name;
         ordered-by user;
         description "Forwarding class to map to queue number";
         max-elements 16;
         leaf name {
           description "Name of forwarding class";
           type string {
             length "1 .. 64";
           }
         }
         leaf queue-num {
           description "Queue number";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32;
           }
         }
         leaf priority {
           description "Fabric priority";
           type enumeration {
             enum "low" {
               description "Low fabric priority";
             }
             enum "high" {
               description "High fabric priority";
             }
           }
         }
         leaf policing-priority {
           description "Policing priority for hierarchical policers";
           type enumeration {
             enum "normal" {
               description "Normal policing priority";
             }
             enum "premium" {
               description "Premium policing priority";
             }
           }
         }
       }
       list queue {
         key name;
         ordered-by user;
         description "Queue number to map to forwarding class";
         leaf name {
           description "Queue number";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32;
           }
         }
         leaf class-name {
           description "Forwarding class name";
           type string {
             length "1 .. 64";
           }
         }
         leaf priority {
           description "Fabric priority";
           type enumeration {
             enum "low" {
               description "Fabric priority low";
             }
             enum "high" {
               description "Fabric priority high";
             }
           }
         }
         leaf policing-priority {
           description "Policing priority for hierarchical policers";
           type enumeration {
             enum "normal" {
               description "Normal policing priority";
             }
             enum "premium" {
               description "Premium policing priority";
             }
           }
         }
       }
     }
     container restricted-queues {
       description "Map forwarding classes to restricted queues";
       uses apply-advanced;
       list forwarding-class {
         key name;
         ordered-by user;
         description "Forwarding class to map to a restricted queue";
         leaf name {
           description "Forwarding class name";
           type string {
             length "1 .. 64";
           }
         }
         leaf rqueue-num {
           description "Restricted queue number";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 3";
             }
           }
         }
       }
     }
     list traffic-control-profiles {
       key name;
       ordered-by user;
       description "Traffic shaping and scheduling profiles";
       leaf name {
         description "Traffic control profile name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       leaf scheduler-map {
         description "Mapping of forwarding classes to packet schedulers";
         type string {
           length "1 .. 64";
         }
       }
       leaf strict-priority-scheduler {
         description "Enable strict priority scheduler.";
         type empty;
       }
       leaf atm-service {
         description "ATM service category";
         type enumeration {
           enum "cbr" {
             description "Constant bit rate";
           }
           enum "rtvbr" {
             description "Real-time variable bit rate";
           }
           enum "nrtvbr" {
             description "Non-real-time variable bit rate";
           }
         }
       }
       leaf peak-rate {
         description "ATM Peak Cell Rate (PCR)";
         units "cps";
         type string;
       }
       leaf sustained-rate {
         description "ATM Sustained Cell Rate (SCR)";
         units "cps";
         type string;
       }
       leaf max-burst-size {
         description "ATM Maximum Burst Size (MBS)";
         units "cells";
         type union {
           type string {
             pattern "<.*>|$.*";
           }
           type uint64 {
             range "1 .. 4000";
           }
         }
       }
       container shaping-rate {
         description "Shaping rate";
         choice shaping_rate_choice {
           case case_1 {
             leaf rate {
               description "Shaping rate as an absolute rate";
               units "bits per second";
               type string;
             }
           }
           case case_2 {
             leaf percent {
               description "Shaping rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container overhead-accounting {
         description "Overhead accounting";
         leaf mode {
           type string {
             length "1 .. 64";
           }
         }
         leaf bytes {
           description "Byte adjust value";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type int32 {
               range "-120 .. 124";
             }
           }
         }
         leaf frame-mode-bytes {
           description "Overhead bytes when in frame-mode";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type int32 {
               range "-120 .. 124";
             }
           }
         }
         leaf cell-mode-bytes {
           description "Overhead bytes when in cell-mode";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type int32 {
               range "-120 .. 124";
             }
           }
         }
       }
       container shaping-rate-priority-strict-high {
         description "Shaping rate for strict high priority traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-priority-high {
         description "Shaping rate for high priority traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-priority-medium {
         description "Shaping rate for medium priority traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-priority-medium-low {
         description "Shaping rate for medium low priority traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-priority-low {
         description "Shaping rate for low priority traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-excess-high {
         description "Shaping rate for excess high traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-excess-low {
         description "Shaping rate for excess low traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-excess-medium-high {
         description "Shaping rate for excess medium-high traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container shaping-rate-excess-medium-low {
         description "Shaping rate for excess medium-low traffic";
         leaf rate {
           description "Shaping rate in bits per second";
           units "bits per second";
           type string;
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container guaranteed-rate {
         description "Guaranteed rate";
         choice guaranteed_rate_choice {
           case case_1 {
             leaf rate {
               description "Guaranteed rate as an absolute rate";
               units "bits per second";
               type string;
             }
           }
           case case_2 {
             leaf percent {
               description "Guaranteed rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
         leaf burst-size {
           description "Guaranteed rate burst size";
           units "bytes";
           type string;
         }
       }
       container excess-rate {
         description "Excess bandwidth sharing proportion";
         choice excess_rate_choice {
           case case_1 {
             leaf proportion {
               description "Excess rate as a proportion";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 1000";
                 }
               }
             }
           }
           case case_2 {
             leaf percent {
               description "Excess rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
       }
       container excess-rate-high {
         description "Excess bandwidth sharing for excess-high priority";
         choice excess_rate_choice {
           case case_1 {
             leaf proportion {
               description "Excess rate as a proportion";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 1000";
                 }
               }
             }
           }
           case case_2 {
             leaf percent {
               description "Excess rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
       }
       container excess-rate-medium-high {
         description "Excess bandwidth sharing for excess-medium-high priority";
         choice excess_rate_choice {
           case case_1 {
             leaf proportion {
               description "Excess rate as a proportion";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 1000";
                 }
               }
             }
           }
           case case_2 {
             leaf percent {
               description "Excess rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
       }
       container excess-rate-low {
         description "Excess bandwidth sharing for excess-low priority";
         choice excess_rate_choice {
           case case_1 {
             leaf proportion {
               description "Excess rate as a proportion";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 1000";
                 }
               }
             }
           }
           case case_2 {
             leaf percent {
               description "Excess rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
       }
       container excess-rate-medium-low {
         description "Excess bandwidth sharing for excess-medium-low priority";
         choice excess_rate_choice {
           case case_1 {
             leaf proportion {
               description "Excess rate as a proportion";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 1000";
                 }
               }
             }
           }
           case case_2 {
             leaf percent {
               description "Excess rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
       }
       choice delay_buffer_sizing {
         case case_1 {
           container delay-buffer-rate {
             description "Delay buffer rate";
             choice delay_buffer_rate_choice {
               case case_1 {
                 leaf rate {
                   description "Delay buffer rate as an absolute rate";
                   units "bits per second";
                   type string;
                 }
               }
               case case_2 {
                 leaf percent {
                   description "Delay buffer rate as a percentage";
                   type union {
                     type string {
                       pattern "<.*>|$.*";
                     }
                     type uint32 {
                       range "1 .. 100";
                     }
                   }
                 }
               }
               case case_3 {
                 leaf cps {
                   description "Delay buffer rate as an absolute cells per second rate";
                   units "cells per second";
                   type string;
                 }
               }
             }
           }
         }
       }
       container adjust-minimum {
         description "Minimum shaping-rate when adjusted";
         leaf rate {
           description "Minimum shaping rate in bits per second";
           units "bits per second";
           type string;
         }
       }
     }
     list forwarding-class-sets {
       key name;
       ordered-by user;
       description "Forwarding class sets";
       leaf name {
         description "Forwarding class set";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list class {
         key name;
         ordered-by user;
         description "Forwarding class";
         leaf name {
           description "Class name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
       }
     }
     container system-defaults {
       description "System defaults";
       uses apply-advanced;
       container classifiers {
         description "System wide Classifiers applied to incoming packets";
         uses apply-advanced;
         container exp {
           description "EXP classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
       }
     }
     container dynamic-class-of-service-options {
       description "Dynamic class-of-service options";
       uses apply-advanced;
       list vendor-specific-tags {
         key name;
         ordered-by user;
         description "Enable vendor specific tags";
         leaf name {
           type enumeration {
             enum "actual-data-rate-downstream" {
               description "Enable shaping based on actual-data-rate-downstream";
             }
             enum "access-loop-encapsulation" {
               description "Enable overhead-accounting based on access-loop-encapsulation";
             }
             enum "apply-to-interface-set" {
               description "Apply adjusted rate to the underlying interface-set";
             }
           }
         }
         uses apply-advanced;
       }
     }
     container interfaces {
       description "Apply class-of-service options to interfaces";
       uses apply-advanced;
       list interface-set {
         key name;
         ordered-by user;
         description "Interface set traffic-control-profile attachment";
         leaf name {
           description "Name of the interface set";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf internal-node {
           description "Internal node";
           type empty;
         }
         container input-excess-bandwidth-share {
           description "Input Excess bandwidth sharing policy";
           choice input_excess_bandwidth_share {
             case case_1 {
               leaf proportional {
                 description "Maximum Queue Bandwidth";
                 units "bits per second";
                 type string;
               }
             }
             case case_2 {
               leaf equal {
                 description "Equal sharing of excess bandwidth";
                 type empty;
               }
             }
           }
         }
         container excess-bandwidth-share {
           description "Output Excess bandwidth sharing policy";
           choice output_excess_bandwidth_share {
             case case_1 {
               leaf proportional {
                 description "Maximum Queue Bandwidth";
                 units "bits per second";
                 type string;
               }
             }
             case case_2 {
               leaf equal {
                 description "Equal sharing of excess bandwidth";
                 type empty;
               }
             }
           }
         }
         container input-traffic-control-profile {
           description "Input traffic control profile for the interface set";
           leaf profile-name {
             description "Name of the input traffic control profile associated with the interface set";
             type string {
               length "1 .. 64";
             }
           }
         }
         container input-traffic-control-profile-remaining {
           description "Input traffic control profile for the remaining traffic on an interface set";
           leaf profile-name {
             description "Name of the input traffic control profile associated with the remaining traffic for the interface set";
             type string {
               length "1 .. 64";
             }
           }
         }
         container output-traffic-control-profile {
           description "Output traffic control profile for the interface set";
           leaf profile-name {
             description "Name of the output traffic control profile associated with the interface set";
             type string {
               length "1 .. 64";
             }
           }
         }
         container output-traffic-control-profile-remaining {
           description "Output traffic control profile for the remaining traffic on an interface set";
           leaf profile-name {
             description "Name of the output traffic control profile associated with the remaining traffic for the interface set";
             type string {
               length "1 .. 64";
             }
           }
         }
       }
       list interface {
         key name;
         uses cos_interfaces_type;
       }
     }
     list routing-instances {
       key name;
       ordered-by user;
       description "Apply CoS options to routing instances with VRF table label";
       leaf name {
         description "Routing instance name (or wildcard)";
         type string {
         }
       }
       uses apply-advanced;
       container classifiers {
         description "Classifiers applied to incoming packets";
         uses apply-advanced;
         leaf no-default {
           description "Do not apply default classifiers to this interface";
           type empty;
         }
         container exp {
           description "EXP classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         container ieee-802.1 {
           description "IEEE-802.1 classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf encapsulated {
             description "Inner or outer ethernet header";
             type empty;
           }
           leaf vlan-tag {
             description "VLAN tag used for classification";
             type enumeration {
               enum "outer" {
                 description "Classification based on outer VLAN tag";
               }
               enum "inner" {
                 description "Classification based on inner VLAN tag";
               }
             }
           }
         }
         container dscp {
           description "Differentiated Services code point classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         container dscp-ipv6 {
           description "Differentiated Services code point classifier IPv6";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
       }
       container rewrite-rules {
         description "Rewrite rules applied to outgoing packets";
         uses apply-advanced;
         choice _802_rewrites {
           case case_1 {
             container ieee-802.1 {
               description "IEEE-802.1 rewrite rule";
               leaf rewrite-rule-name {
                 description "Name of rewrite rule to be applied";
                 type union {
                   type string {
                     pattern "default";
                   }
                   type string {
                     length "1 .. 64";
                   }
                 }
               }
               leaf encapsulated {
                 description "Inner ethernet header";
                 type empty;
               }
               leaf vlan-tag {
                 description "One or more VLAN tags to which rewrite rule applies";
                 type enumeration {
                   enum "outer" {
                     description "Rewrite rule applies to outer VLAN tag";
                   }
                   enum "outer-and-inner" {
                     description "Rewrite rule applies to outer and inner VLAN tag";
                   }
                 }
               }
             }
           }
           case case_2 {
             container ieee-802.1ad {
               description "IEEE-802.1ad (DEI) rewrite rule";
               leaf rewrite-rule-name {
                 description "Name of rewrite rule to be applied";
                 type union {
                   type string {
                     pattern "default";
                   }
                   type string {
                     length "1 .. 64";
                   }
                 }
               }
               leaf encapsulated {
                 description "Inner ethernet header";
                 type empty;
               }
               leaf vlan-tag {
                 description "One or more VLAN tags to which rewrite rule applies";
                 type enumeration {
                   enum "outer" {
                     description "Rewrite rule applies to outer VLAN tag";
                   }
                   enum "outer-and-inner" {
                     description "Rewrite rule applies to outer and inner VLAN tag";
                   }
                 }
               }
             }
           }
         }
       }
       container policy-map {
         description "Policy-map describing the packet marking rule";
         leaf policy-map-name {
           description "Name of Policy-map to be applied";
           type string;
         }
       }
     }
     container rewrite-rules {
       description "Write code point value of outgoing packets";
       uses apply-advanced;
       list dscp {
         key name;
         ordered-by user;
         description "Differentiated Services code point rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list dscp-ipv6 {
         key name;
         ordered-by user;
         description "Differentiated Services code point rewrite rule IPv6";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list exp {
         key name;
         ordered-by user;
         description "MPLS EXP rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list ieee-802.1 {
         key name;
         ordered-by user;
         description "IEEE-802.1 rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list inet-precedence {
         key name;
         ordered-by user;
         description "IPv4 precedence rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list frame-relay-de {
         key name;
         ordered-by user;
         description "Frame relay discard eligible bit rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list ieee-802.1ad {
         key name;
         ordered-by user;
         description "IEEE-802.1ad (DEI) rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
       list inet6-precedence {
         key name;
         ordered-by user;
         description "IPv6 precedence rewrite rule";
         leaf name {
           description "Rewrite rule name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         leaf import {
           description "Include this rewrite rule in this definition";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         list forwarding-class {
           key name;
           ordered-by user;
           description "Markings for named forwarding class";
           leaf name {
             description "Forwarding class name";
             type string {
               length "1 .. 64";
             }
           }
           uses apply-advanced;
           list loss-priority {
             key name;
             ordered-by user;
             description "Code point marking based on loss priority";
             leaf name {
               type enumeration {
                 enum "low" {
                   description "Marking when loss priority is low";
                 }
                 enum "high" {
                   description "Marking when loss priority is high";
                 }
                 enum "medium-low" {
                   description "Marking when loss priority is medium-low";
                 }
                 enum "medium-high" {
                   description "Marking when loss priority is medium-high";
                 }
               }
             }
             leaf code-point {
               description "Code point aliases or bit string";
               type string {
               }
             }
           }
         }
       }
     }
     container fabric {
       description "Define CoS parameters of switch fabric";
       uses apply-advanced;
       container scheduler-map {
         description "Mapping of fabric traffic to packet schedulers";
         uses apply-advanced;
         list priority {
           key name;
           ordered-by user;
           description "Fabric traffic priority";
           leaf name {
             type enumeration {
               enum "low" {
                 description "Low priority fabric traffic";
               }
               enum "high" {
                 description "High priority fabric traffic";
               }
             }
           }
           leaf scheduler {
             description "Scheduler name";
             type string {
               length "1 .. 64";
             }
           }
         }
       }
     }
     list scheduler-maps {
       key name;
       ordered-by user;
       description "Mapping of forwarding classes to packet schedulers";
       leaf name {
         description "Scheduler map name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list forwarding-class {
         key name;
         ordered-by user;
         description "Forwarding class name to map to scheduler";
         leaf name {
           description "Forwarding class name";
           type string {
             length "1 .. 64";
           }
         }
         leaf scheduler {
           description "Scheduler name";
           type string {
             length "1 .. 64";
           }
         }
       }
     }
     list fragmentation-maps {
       key name;
       ordered-by user;
       description "Mapping of forwarding class to fragmentation options";
       leaf name {
         description "Fragmentation map name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list forwarding-class {
         key name;
         ordered-by user;
         description "Forwarding class name to map to fragmentation options";
         leaf name {
           description "Forwarding class name";
           type string {
             length "1 .. 64";
           }
         }
         uses apply-advanced;
         choice fragmentation-control {
           case case_1 {
             leaf fragment-threshold {
               description "Fragmentation threshold";
               units "bytes";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint16 {
                   range "64 .. 9192";
                 }
               }
             }
           }
           case case_2 {
             leaf no-fragmentation {
               description "Don't allow fragmentation";
               type empty;
             }
           }
         }
         leaf multilink-class {
           description "Multilink-Class assigned to the forwarding class";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint16 {
               range "0 .. 7";
             }
           }
         }
         leaf drop-timeout {
           description "Drop timeout";
           units "milliseconds";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint16 {
               range "0 .. 2000";
             }
           }
         }
       }
     }
     list schedulers {
       key name;
       ordered-by user;
       description "Packet schedulers";
       leaf name {
         description "Scheduler name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       container transmit-rate {
         description "Transmit rate";
         uses apply-advanced;
         choice transmit_rate_choice {
           case case_1 {
             leaf rate {
               description "Transmit rate as rate";
               units "bits per second";
               type string;
             }
           }
           case case_2 {
             leaf percent {
               description "Transmit rate as percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 100";
                 }
               }
             }
           }
           case case_3 {
             container remainder {
               presence "enable remainder";
               description "Remainder available";
               uses apply-advanced;
               leaf percent {
                 default "0";
                 type union {
                   type string {
                     pattern "<.*>|$.*";
                   }
                   type uint32 {
                     range "0 .. 100";
                   }
                 }
               }
             }
           }
         }
         choice rate_limit_choice {
           case case_1 {
             leaf exact {
               description "Enforce exact transmit rate";
               type empty;
             }
           }
           case case_2 {
             leaf rate-limit {
               description "Enforce rate limit that uses policer";
               type empty;
             }
           }
         }
       }
       container excess-rate {
         description "Excess bandwidth sharing proportion";
         choice excess_rate_choice {
           case case_1 {
             leaf proportion {
               description "Excess rate as a proportion";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 1000";
                 }
               }
             }
           }
           case case_2 {
             leaf percent {
               description "Excess rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
       }
       container shaping-rate {
         description "Shaping rate";
         choice shaping_rate_choice {
           case case_1 {
             leaf rate {
               description "Shaping rate as an absolute rate";
               units "bits per second";
               type string;
             }
           }
           case case_2 {
             leaf percent {
               description "Shaping rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "1 .. 100";
                 }
               }
             }
           }
         }
         leaf burst-size {
           description "Shaping rate burst size";
           units "bytes";
           type string;
         }
       }
       container buffer-size {
         description "Queue transmission buffer size";
         uses apply-advanced;
         choice buffer_size_choice {
           case case_1 {
             leaf percent {
               description "Buffer size as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 100";
                 }
               }
             }
           }
           case case_2 {
             container remainder {
               presence "enable remainder";
               description "Remainder of buffer size available";
               uses apply-advanced;
               leaf percent {
                 default "0";
                 type union {
                   type string {
                     pattern "<.*>|$.*";
                   }
                   type uint32 {
                     range "0 .. 100";
                   }
                 }
               }
             }
           }
           case case_3 {
             leaf shared {
               description "Shared buffer allocation";
               type empty;
             }
           }
           case case_4 {
             leaf temporal {
               description "Buffer size as temporal value";
               units "microseconds";
               type string;
             }
           }
         }
         choice buffer_limit {
           case case_1 {
             leaf exact {
               description "Enforce exact buffer size";
               type empty;
             }
           }
         }
         container buffer-partition {
           presence "enable buffer-partition";
           description "Partition buffer size among multicast and unicast";
           uses apply-advanced;
           container multicast {
             presence "enable multicast";
             description "Specify multicast fraction of reserved buffer";
             uses apply-advanced;
             leaf percent {
               default "50";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 100";
                 }
               }
             }
           }
         }
       }
       container shared-buffer {
         description "Queue transmission shared-buffer";
         uses apply-advanced;
         container maximum {
           presence "enable maximum";
           description "Control the amount of shared buffer a given queue can consume";
           uses apply-advanced;
           leaf percent {
             description "Maximum shared buffer size as a percentage";
             default "0";
             type union {
               type string {
                 pattern "<.*>|$.*";
               }
               type uint32 {
                 range "0 .. 100";
               }
             }
           }
           container multicast {
             presence "enable multicast";
             description "Control the amount of shared buffer mcast pkts consume";
             uses apply-advanced;
             leaf percent {
               description "Maximum shared buffer size as a percentage";
               default "0";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 100";
                 }
               }
             }
           }
         }
       }
       leaf priority {
         description "Scheduling priority";
         type string {
           length "1 .. 64";
         }
       }
       leaf excess-priority {
         description "Priority in the excess region";
         type string {
           length "1 .. 64";
         }
       }
       list drop-profile-map {
         key "loss-priority protocol";
         ordered-by user;
         description "Assign drop profile to a loss priority and protocol";
         leaf loss-priority {
           description "Loss priority value";
           type enumeration {
             enum "low" {
               description "Loss priority low";
             }
             enum "high" {
               description "Loss priority high";
             }
             enum "medium-low" {
               description "Loss priority medium-low";
             }
             enum "medium-high" {
               description "Loss priority medium-high";
             }
             enum "any" {
               description "Ignore loss priority when assigning drop profile";
             }
           }
         }
         leaf protocol {
           description "Protocol type";
           type enumeration {
             enum "tcp" {
               description "TCP protocol only";
             }
             enum "non-tcp" {
               description "Non-TCP protocols only";
             }
             enum "any" {
               description "Ignore protocol type when assigning drop profile";
             }
           }
         }
         leaf drop-profile {
           description "Name of drop profile to apply";
           type string {
             length "1 .. 64";
           }
         }
       }
       leaf explicit-congestion-notification {
         description "Enable or Disable Explicit Congestion Notification";
         type empty;
       }
       leaf adjust-percent {
         description "Percent of a bandwidth adjustment applied to a queue";
         units "percent";
         type union {
           type string {
             pattern "<.*>|$.*";
           }
           type uint32 {
             range "0 .. 100";
           }
         }
       }
       leaf adjust-minimum {
         description "Minimum shaping-rate when adjusted";
         units "bits per second";
         type string;
       }
     }
     list adjustment-control-profiles {
       key name;
       description "Adjustment control profiles";
       leaf name {
         description "Adjustment control profile name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       list application {
         key name;
         ordered-by user;
         description "Applications that can perform adjustments";
         leaf name {
           description "Applications that can perform adjustments";
           type enumeration {
             enum "ancp" {
               description "Access Node Configuration Protocol";
             }
             enum "radius-coa" {
               description "RADIUS Change of Authorization";
             }
             enum "pppoe-tags" {
               description "Point to Point Protocol over Ethernet IA Tags";
             }
             enum "dhcp-tags" {
               description "Dynamic Host Configuration Protocol Tags";
             }
           }
         }
         leaf priority {
           description "Priority for the application; 1 is the highest";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "1 .. 10";
             }
           }
         }
         leaf algorithm {
           description "Adjustment algorithm for the application";
           type enumeration {
             enum "adjust-less" {
               description "Adjust if less than the configured value";
             }
             enum "adjust-less-or-equal" {
               description "Adjust if <= the configured value";
             }
             enum "adjust-greater" {
               description "Adjust if greater than the configured value";
             }
             enum "adjust-greater-or-equal" {
               description "Adjust if >= the configured value";
             }
             enum "adjust-always" {
               description "Adjust unconditionally";
             }
             enum "adjust-never" {
               description "Do not perform adjustments";
             }
           }
         }
       }
     }
     container traceoptions {
       description "Trace options for class-of-service process";
       uses apply-advanced;
       leaf no-remote-trace {
         description "Disable remote tracing";
         type empty;
       }
       container file {
         description "Trace file information";
         leaf filename {
           description "Name of file in which to write trace information";
           type string {
             length "1 .. 1024";
           }
         }
         leaf size {
           description "Maximum trace file size";
           type string;
         }
         leaf files {
           description "Maximum number of trace files";
           default "3";
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "2 .. 1000";
             }
           }
         }
         choice world-readable-choice {
           leaf world-readable {
             description "Allow any user to read the log file";
             type empty;
           }
           leaf no-world-readable {
             description "Don't allow any user to read the log file";
             type empty;
           }
         }
         leaf match {
           description "Regular expression for lines to be logged";
           type jt:regular-expression;
         }
       }
       list flag {
         key name;
         ordered-by user;
         description "Tracing parameters";
         leaf name {
           type enumeration {
             enum "init" {
               description "Trace initialization events";
             }
             enum "show" {
               description "Trace show command servicing";
             }
             enum "route-socket" {
               description "Trace route-socket events";
             }
             enum "parse" {
               description "Trace parser processing";
             }
             enum "process" {
               description "Trace configuration processing";
             }
             enum "util" {
               description "Trace utilities";
             }
             enum "restart" {
               description "Trace restart processing";
             }
             enum "snmp" {
               description "Trace SNMP-related processing";
             }
             enum "hardware-database" {
               description "Trace chassis hardware database related processing";
             }
             enum "asynch" {
               description "Trace asynchronous configuration processing";
             }
             enum "dynamic" {
               description "Trace dynamic CoS functions";
             }
             enum "cos-adjustment" {
               description "Trace CoS rate adjustments";
             }
             enum "performance-monitor" {
               description "Trace performance monitor counters";
             }
             enum "chassis-scheduler" {
               description "Trace chassis stream scheduler processing";
             }
             enum "cn-util" {
               description "Trace utilities for congestion-notification";
             }
             enum "snmp-timeouts" {
               description "Trace SNMP COSD kernel timeouts";
             }
             enum "all" {
               description "Trace everything";
             }
             enum "feature-capability" {
               description "Trace feature capability";
             }
             enum "application" {
               description "Trace Junos application programming";
             }
           }
         }
       }
     }
     container forwarding-policy {
       description "Class-of-service forwarding policy";
       uses apply-advanced;
       list next-hop-map {
         key name;
         ordered-by user;
         description "Class-of-service next-hop map";
         leaf name {
           description "Name to identify next-hop map";
           type string {
           }
         }
         uses apply-advanced;
         list forwarding-class {
           key name;
           ordered-by user;
           description "Forwarding class from which to map";
           leaf name {
             description "Forwarding class";
             type string {
             }
           }
           uses apply-advanced;
           leaf-list next-hop {
             ordered-by user;
             description "Next-hop identifier to which to map";
             type union {
               type jt:ipaddr-or-interface;
               type string {
                 pattern "<.*>|$.*";
               }
             }
           }
           leaf-list lsp-next-hop {
             ordered-by user;
             description "Regular expression for LSP next hop";
             type string;
           }
           leaf non-lsp-next-hop {
             description "Any non-RSVP LSP next hop";
             type empty;
           }
           leaf non-labelled-next-hop {
             description "Any non-labelled next hop";
             type empty;
           }
           leaf discard {
             description "Discard next hop";
             type empty;
           }
         }
         container forwarding-class-default {
           description "Next Hop For traffic which does not meet any FC in the next-hop-map";
           uses apply-advanced;
           leaf-list next-hop {
             ordered-by user;
             description "Next-hop identifier to which to map";
             type union {
               type jt:ipaddr-or-interface;
               type string {
                 pattern "<.*>|$.*";
               }
             }
           }
           leaf-list lsp-next-hop {
             ordered-by user;
             description "Regular expression for LSP next hop";
             type string;
           }
           leaf non-lsp-next-hop {
             description "Any non-RSVP LSP next hop";
             type empty;
           }
           leaf non-labelled-next-hop {
             description "Any non-labelled next hop";
             type empty;
           }
           leaf discard {
             description "Discard next hop";
             type empty;
           }
         }
       }
       list class {
         key name;
         ordered-by user;
         description "Class-of-service description";
         leaf name {
           description "Name to identify class of service";
           type string {
           }
         }
         uses apply-advanced;
         container classification-override {
           description "Define classification overrides";
           uses apply-advanced;
           leaf forwarding-class {
             description "Forwarding class name";
             type string {
             }
           }
         }
       }
     }
   }
   grouping apply-advanced {
     description "Apply advanced configuration logic";
     leaf-list apply-groups {
       ordered-by user;
       description "Groups from which to inherit configuration data";
       type string;
     }
     leaf-list apply-groups-except {
       ordered-by user;
       description "Don't inherit configuration data from these groups";
       type string;
     }
     list apply-macro {
       key name;
       ordered-by user;
       description "Macro and parameters for commit script expansion";
       uses apply-macro-type;
     }
   }
   grouping apply-macro-type {
     description "Macro data for commit-script expansion";
     leaf name {
       description "Name of the macro to be expanded";
       type string;
     }
     list data {
       key name;
       uses macro-data-type;
     }
   }
   grouping cos_interfaces_type {
     description "Physical interface";
     leaf name {
       description "Interface name (or wildcard)";
       type union {
         type jt:interface-device-wildcard;
         type string {
           pattern "<.*>|$.*";
         }
       }
     }
     uses apply-advanced;
     list forwarding-class-set {
       key name;
       ordered-by user;
       description "Map forwarding class sets to output traffic control profile";
       max-elements 4;
       leaf name {
         description "Forwarding class sets name";
         type string {
           length "1 .. 64";
         }
       }
       uses apply-advanced;
       container output-traffic-control-profile {
         description "Output traffic control profile for the interface";
         leaf profile-name {
           description "Name of the output traffic control profile associated with the interface";
           type string {
             length "1 .. 64";
           }
         }
       }
     }
     leaf scheduler-map {
       description "Output scheduler map";
       type string {
         length "1 .. 64";
       }
     }
     leaf input-scheduler-map {
       description "Input scheduler map";
       type string {
         length "1 .. 64";
       }
     }
     leaf scheduler-map-chassis {
       description "Scheduler map applied to chassis queues (not PIC queues)";
       type union {
         type string {
           pattern "derived";
         }
         type string {
           length "1 .. 64";
         }
       }
     }
     leaf output-forwarding-class-map {
       description "Output forwarding class map name";
       type string {
         length "1 .. 64";
       }
     }
     container shaping-rate {
       description "Output shaping rate";
       leaf rate {
         description "Shaping rate as an absolute rate";
         units "bits per second";
         type string;
       }
     }
     container input-excess-bandwidth-share {
       description "Input Excess bandwidth sharing policy";
       choice input_excess_bandwidth_share {
         case case_1 {
           leaf proportional {
             description "Maximum Queue Bandwidth";
             units "bits per second";
             type string;
           }
         }
         case case_2 {
           leaf equal {
             description "Equal sharing of excess bandwidth";
             type empty;
           }
         }
       }
     }
     container excess-bandwidth-share {
       description "Output Excess bandwidth sharing policy";
       choice output_excess_bandwidth_share {
         case case_1 {
           leaf proportional {
             description "Maximum Queue Bandwidth";
             units "bits per second";
             type string;
           }
         }
         case case_2 {
           leaf equal {
             description "Equal sharing of excess bandwidth";
             type empty;
           }
         }
       }
     }
     container input-shaping-rate {
       description "Input shaping rate";
       leaf rate {
         description "Input shaping rate as an absolute rate";
         units "bits per second";
         type string;
       }
     }
     container input-traffic-control-profile {
       description "Input traffic control profile";
       leaf profile-name {
         description "Name of the traffic control profile";
         type string {
           length "1 .. 64";
         }
       }
     }
     container input-traffic-control-profile-remaining {
       description "Input traffic control profile for remaining traffic on the ifd";
       leaf profile-name {
         description "Name of the traffic control profile";
         type string {
           length "1 .. 64";
         }
       }
     }
     container output-traffic-control-profile {
       description "Output traffic control profile";
       leaf profile-name {
         description "Name of the traffic control profile";
         type string {
           length "1 .. 64";
         }
       }
     }
     container output-traffic-control-profile-remaining {
       description "Output traffic control profile for remaining traffic on the ifd";
       leaf profile-name {
         description "Name of the traffic control profile";
         type string {
           length "1 .. 64";
         }
       }
     }
     container member-link-scheduler {
       description "Scheduler parameter model for member link";
       choice model {
         case case_1 {
           leaf scale {
             description "Scale scheduler parameters on aggregate interface";
             type empty;
           }
         }
         case case_2 {
           leaf replicate {
             description "Copy scheduler parameters from aggregate interface";
             type empty;
           }
         }
       }
     }
     container traffic-class-map {
       description "Packet code point to input priority mapping";
       uses apply-advanced;
       container inet-precedence {
         description "IPv4 precedence code point traffic-class-map";
         uses apply-advanced;
         leaf traffic-class-map-name {
           description "Name of traffic-class-map to be applied on IFD";
           type string {
             length "1 .. 64";
           }
         }
       }
       container dscp {
         description "Differentiated services code point traffic-class-map";
         uses apply-advanced;
         leaf traffic-class-map-name {
           description "Name of traffic-class-map to be applied on IFD";
           type string {
             length "1 .. 64";
           }
         }
       }
       container exp {
         description "MPLS experimental code point traffic-class-map";
         uses apply-advanced;
         leaf traffic-class-map-name {
           description "Name of traffic-class-map to be applied on IFD";
           type string {
             length "1 .. 64";
           }
         }
       }
       container ieee-802.1 {
         description "IEEE-802.1 code point traffic-class-map";
         uses apply-advanced;
         leaf traffic-class-map-name {
           description "Name of traffic-class-map to be applied on IFD";
           type string {
             length "1 .. 64";
           }
         }
         leaf vlan-tag {
           description "VLAN tag used for traffic-class-map";
           type enumeration {
             enum "outer" {
               description "Traffic-class-map based on outer VLAN tag";
             }
             enum "inner" {
               description "Traffic-class-map based on inner VLAN tag";
             }
           }
         }
       }
       container ieee-802.1ad {
         description "IEEE-802.1ad (DEI) code point traffic-class-map";
         uses apply-advanced;
         leaf traffic-class-map-name {
           description "Name of traffic-class-map to be applied on IFD";
           type string {
             length "1 .. 64";
           }
         }
         leaf vlan-tag {
           description "VLAN tag used for traffic-class-map";
           type enumeration {
             enum "outer" {
               description "Traffic-class-map based on outer VLAN tag";
             }
             enum "inner" {
               description "Traffic-class-map based on inner VLAN tag";
             }
           }
         }
       }
     }
     container exclude-queue-overhead-bytes {
       presence "enable exclude-queue-overhead-bytes";
       description "Exclude the overhead bytes from the queue statistics";
       uses apply-advanced;
       leaf include-hierarchy {
         description "Perform overhead adjustment on IFD and all children";
         type empty;
       }
     }
     container logical-interface-aggregate-statistics {
       presence "enable logical-interface-aggregate-statistics";
       description "Logical interface aggregate queue statistics";
     }
     list unit {
       key name;
       description "Logical interface unit (or wildcard)";
       leaf name {
         description "Logical unit number";
         type union {
           type string {
             pattern "\*";
           }
           type union {
             type string {
               pattern "<.*>|$.*";
             }
             type uint32 {
               range "0 .. 1073741823";
             }
           }
         }
       }
       uses apply-advanced;
       leaf output-forwarding-class-map {
         description "Output forwarding class map name";
         type string {
           length "1 .. 64";
         }
       }
       leaf forwarding-class {
         description "Forwarding class assigned to incoming packets";
         type string {
           length "1 .. 64";
         }
       }
       leaf virtual-channel-group {
         description "Virtual channel group applied to this logical interface";
         type string {
           length "1 .. 64";
         }
       }
       leaf vc-shared-scheduler {
         description "Virtual channel group shared scheduler indicator";
         type empty;
       }
       leaf scheduler-map {
         description "Output scheduler map";
         type string {
           length "1 .. 64";
         }
       }
       leaf input-scheduler-map {
         description "Input scheduler map";
         type string {
           length "1 .. 64";
         }
       }
       leaf fragmentation-map {
         description "Fragmentation map applied to this logical interface";
         type string {
           length "1 .. 64";
         }
       }
       leaf adaptive-shaper {
         description "Adaptive shaper applied to this logical interface";
         type string {
           length "1 .. 64";
         }
       }
       container shaping-rate {
         presence "enable shaping-rate";
         description "Output shaping rate";
         choice shaping_rate_choice {
           case case_1 {
             leaf rate {
               description "Shaping rate as an absolute rate";
               units "bits per second";
               type string;
             }
           }
           case case_2 {
             leaf percent {
               description "Shaping rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 100";
                 }
               }
             }
           }
         }
       }
       container input-shaping-rate {
         description "Input shaping rate";
         choice shaping_rate_choice {
           case case_1 {
             leaf rate {
               description "Shaping rate as an absolute rate";
               units "bits per second";
               type string;
             }
           }
           case case_2 {
             leaf percent {
               description "Shaping rate as a percentage";
               type union {
                 type string {
                   pattern "<.*>|$.*";
                 }
                 type uint32 {
                   range "0 .. 100";
                 }
               }
             }
           }
         }
       }
       container input-traffic-control-profile {
         description "Input traffic control profile";
         leaf profile-name {
           description "Name of traffic control profile";
           type string {
             length "1 .. 64";
           }
         }
         leaf shared-instance {
           description "Name of the shared instance";
           type string {
             length "1 .. 64";
           }
         }
       }
       container output-traffic-control-profile {
         description "Output traffic control profile";
         leaf profile-name {
           description "Name of the traffic control profile";
           type string {
             length "1 .. 64";
           }
         }
         leaf shared-instance {
           description "Name of the shared instance";
           type string {
             length "1 .. 64";
           }
         }
       }
       container output-traffic-control-profile-remaining {
         description "Output traffic control profile for remaining traffic on the ifl";
         leaf profile-name {
           description "Name of the traffic control profile";
           type string {
           }
         }
       }
       container report-ingress-shaping-rate {
         description "Report ingress shaping rate";
         choice report_ingress_shaping_rate_choice {
           case case_1 {
             leaf rate {
               description "Ingress shaping rate as an absolute value";
               units "bits per second";
               type string;
             }
           }
         }
       }
       container classifiers {
         description "Classifiers applied to incoming packets";
         uses apply-advanced;
         leaf no-default {
           description "Do not apply default classifiers to this interface";
           type empty;
         }
         list dscp {
           key name;
           ordered-by user;
           description "Differentiated Services code point classifier";
           leaf name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           uses apply-advanced;
           leaf-list family {
             ordered-by user;
             description "Family for DSCP classifier";
             type string;
           }
         }
         list dscp-ipv6 {
           key name;
           ordered-by user;
           description "Differentiated Services code point classifier IPv6";
           leaf name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           uses apply-advanced;
           leaf-list family {
             ordered-by user;
             description "Family for DSCP Ipv6 classifier";
             type string;
           }
         }
         container exp {
           description "EXP classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         container ieee-802.1 {
           description "IEEE-802.1 classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf vlan-tag {
             description "VLAN tag used for classification";
             type enumeration {
               enum "outer" {
                 description "Classification based on outer VLAN tag";
               }
               enum "inner" {
                 description "Classification based on inner VLAN tag";
               }
               enum "transparent" {
                 description "Classification based on hidden VLAN tag";
               }
             }
           }
         }
         container inet-precedence {
           description "IPv4 precedence classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         container ieee-802.1ad {
           description "IEEE-802.1ad (DEI) classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf vlan-tag {
             description "VLAN tag used for classification";
             type enumeration {
               enum "outer" {
                 description "Classification based on outer VLAN tag";
               }
               enum "inner" {
                 description "Classification based on inner VLAN tag";
               }
             }
           }
         }
       }
       container ingress-rewrite-rules {
         description "Rewrite rules applied to outgoing packets of the ingress interface";
         uses apply-advanced;
         list dscp {
           key name;
           ordered-by user;
           description "Differentiated Services code point rewrite rule";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         container dscp-ipv6 {
           description "Differentiated Services code point rewrite rule IPv6";
           leaf rewrite-rule-name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         list inet-precedence {
           key name;
           ordered-by user;
           description "IPv4 precedence rewrite rule";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
       }
       container loss-priority-maps {
         description "Loss priority maps applied to incoming packets";
         uses apply-advanced;
         container frame-relay-de {
           description "Frame Relay discard eligible bit loss priority map";
           leaf lpmap-name {
             description "Name of loss priority map to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
       }
       container rewrite-rules {
         description "Rewrite rules applied to outgoing packets";
         uses apply-advanced;
         list dscp {
           key name;
           ordered-by user;
           description "Differentiated Services code point rewrite rule";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf-list protocol {
             ordered-by user;
             description "Specify protocol matching criteria";
             type enumeration {
               enum "mpls" {
                 description "Apply to IPv4 packets entering MPLS tunnel";
               }
               enum "gtp-inet-outer" {
                 description "Apply to outer IP header";
               }
               enum "gtp-inet-both" {
                 description "Apply to both IP header";
               }
               enum "inet-outer" {
                 description "Apply to outer IP header";
               }
               enum "inet-both" {
                 description "Apply to both IP header";
               }
             }
           }
         }
         list dscp-ipv6 {
           key name;
           ordered-by user;
           description "Differentiated Services code point rewrite rule IPv6";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf-list protocol {
             ordered-by user;
             description "Specify protocol matching criteria";
             type enumeration {
               enum "mpls" {
                 description "Apply to IPv6 packets entering MPLS tunnel";
               }
               enum "gtp-inet-outer" {
                 description "Apply to outer IP header";
               }
               enum "gtp-inet-both" {
                 description "Apply to both IP header";
               }
             }
           }
         }
         list exp {
           key name;
           ordered-by user;
           description "EXP rewrite rule";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf-list protocol {
             ordered-by user;
             description "Specify protocol matching criteria";
             type enumeration {
               enum "mpls-any" {
                 description "Apply to MPLS packets, write MPLS header only";
               }
               enum "mpls-inet-both" {
                 description "Apply to IPv4 MPLS packets, write MPLS and IPv4 header";
               }
               enum "mpls-inet-both-non-vpn" {
                 description "Apply to IPv4 MPLS packets, write MPLS and IPv4 header for only non VPN traffic";
               }
             }
           }
         }
         container ieee-802.1 {
           description "IEEE-802.1 rewrite rule";
           leaf rewrite-rule-name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf vlan-tag {
             description "One or more VLAN tags to which rewrite rule applies";
             type enumeration {
               enum "outer" {
                 description "Rewrite rule applies to outer VLAN tag";
               }
               enum "outer-and-inner" {
                 description "Rewrite rule applies to both outer and inner VLAN tags";
               }
             }
           }
         }
         list inet-precedence {
           key name;
           ordered-by user;
           description "IPv4 precedence rewrite rule";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf-list protocol {
             ordered-by user;
             description "Specify protocol matching criteria";
             type enumeration {
               enum "mpls" {
                 description "Apply to IPv4 packets entering MPLS tunnel";
               }
               enum "gtp-inet-outer" {
                 description "Apply to outer IP header";
               }
               enum "gtp-inet-both" {
                 description "Apply to both IP header";
               }
               enum "inet-outer" {
                 description "Apply to outer IP header";
               }
               enum "inet-both" {
                 description "Apply to both IP header";
               }
             }
           }
         }
         container exp-swap-push-push {
           description "Copy incoming EXP into all swap-push-push labels";
           leaf rewrite-rule-name {
             description "Name of rewrite rule to be applied";
             type enumeration {
               enum "default" {
                 description "Apply default rewrite rule";
               }
             }
           }
         }
         container exp-push-push-push {
           description "Top-label EXP rewrite rule for push-push-push operation";
           leaf rewrite-rule-name {
             description "Name of rewrite rule to be applied";
             type enumeration {
               enum "default" {
                 description "Apply default rewrite rule";
               }
             }
           }
         }
         container frame-relay-de {
           description "Frame relay discard eligible bit rewrite rule";
           leaf rewrite-rule-name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
         container ieee-802.1ad {
           description "IEEE-802.1ad (DEI) rewrite rule";
           uses apply-advanced;
           leaf rewrite-rule-name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf vlan-tag {
             description "One or more VLAN tags to which rewrite rule applies";
             type enumeration {
               enum "outer" {
                 description "Rewrite rule applies to outer VLAN tag";
               }
               enum "outer-and-inner" {
                 description "Rewrite rule applies to both outer and inner VLAN tags";
               }
             }
           }
         }
         list inet6-precedence {
           key name;
           ordered-by user;
           description "IPv6 precedence rewrite rule";
           leaf name {
             description "Name of rewrite rule to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
           leaf-list protocol {
             ordered-by user;
             description "Specify protocol matching criteria";
             type enumeration {
               enum "mpls" {
                 description "Apply to IPv6 packets entering MPLS tunnel";
               }
             }
           }
         }
       }
       container loss-priority-rewrites {
         description "Loss priority rewrites applied to outgoing packets";
         uses apply-advanced;
         container frame-relay-de {
           description "Frame Relay discard eligible bit loss priority rewrite";
           leaf lprewrite-name {
             description "Name of loss priority rewrite to be applied";
             type union {
               type string {
                 pattern "default";
               }
               type string {
                 length "1 .. 64";
               }
             }
           }
         }
       }
       container translation-table {
         description "Translation tables applied to incoming packets";
         uses apply-advanced;
         container to-inet-precedence-from-inet-precedence {
           description "IPv4 precedence translation table";
           leaf translation-table-name {
             description "Name of translation table to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
         container to-dscp-from-dscp {
           description "Differentiated Services code point translation table";
           leaf translation-table-name {
             description "Name of translation table to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
         container to-dscp-ipv6-from-dscp-ipv6 {
           description "Differentiated Services code point IPV6 translation table";
           leaf translation-table-name {
             description "Name of translation table to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
         container to-exp-from-exp {
           description "EXP translation table";
           leaf translation-table-name {
             description "Name of translation table to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
       }
       container policy-map {
         description "Policy-map describing the packet marking rule";
         leaf policy-map-name {
           description "Name of Policy-map to be applied";
           type string;
         }
       }
     }
     container classifiers {
       description "Classifiers applied to incoming packets";
       uses apply-advanced;
       list dscp {
         key name;
         ordered-by user;
         description "Differentiated Services code point classifier";
         leaf name {
           description "Name of classifier to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         uses apply-advanced;
       }
       list dscp-ipv6 {
         key name;
         ordered-by user;
         description "Differentiated Services code point classifier IPv6";
         leaf name {
           description "Name of classifier to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         uses apply-advanced;
       }
       container ieee-802.1 {
         description "IEEE-802.1 classifier";
         leaf classifier-name {
           description "Name of classifier to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         leaf vlan-tag {
           description "VLAN tag used for classification";
           type enumeration {
             enum "outer" {
               description "Classification based on outer VLAN tag";
             }
             enum "inner" {
               description "Classification based on inner VLAN tag";
             }
           }
         }
       }
       container ieee-802.1ad {
         description "IEEE-802.1ad (DEI) classifier";
         leaf classifier-name {
           description "Name of classifier to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         leaf vlan-tag {
           description "VLAN tag used for classification";
           type enumeration {
             enum "outer" {
               description "Classification based on outer VLAN tag";
             }
             enum "inner" {
               description "Classification based on inner VLAN tag";
             }
           }
         }
       }
       container inet-precedence {
         description "IPv4 precedence classifier";
         leaf classifier-name {
           description "Name of classifier to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
       }
     }
     leaf forwarding-class {
       description "Forwarding class assigned to incoming packets";
       type string {
       }
     }
     container rewrite-rules {
       description "Rewrite rules applied to outgoing packets";
       uses apply-advanced;
       list dscp {
         key name;
         ordered-by user;
         description "Differentiated Services code point rewrite rule";
         leaf name {
           description "Name of rewrite rule to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
       }
       list dscp-ipv6 {
         key name;
         ordered-by user;
         description "Differentiated Services code point rewrite rule IPv6";
         leaf name {
           description "Name of rewrite rule to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
       }
       container ieee-802.1 {
         description "IEEE-802.1 rewrite rule";
         leaf rewrite-rule-name {
           description "Name of rewrite rule to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
       }
       container ieee-802.1ad {
         description "IEEE-802.1ad (DEI) rewrite rule";
         uses apply-advanced;
         leaf rewrite-rule-name {
           description "Name of rewrite rule to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
         leaf vlan-tag {
           description "One or more VLAN tags to which rewrite rule applies";
           type enumeration {
             enum "outer" {
               description "Rewrite rule applies to outer VLAN tag";
             }
           }
         }
       }
       list inet-precedence {
         key name;
         ordered-by user;
         description "IPv4 precedence rewrite rule";
         leaf name {
           description "Name of rewrite rule to be applied";
           type union {
             type string {
               pattern "default";
             }
             type string {
               length "1 .. 64";
             }
           }
         }
       }
     }
     container multi-destination {
       description "Multi-destination class of service";
       uses apply-advanced;
       container classifiers {
         description "Classifier applied to multi-destination traffic";
         uses apply-advanced;
         container ieee-802.1 {
           description "IEEE-802.1P classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
         container dscp {
           description "Differentiated services code point classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
         container dscp-ipv6 {
           description "Differentiated services code point classifier IPv6";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
         container inet-precedence {
           description "IPv4 precedence classifier";
           leaf classifier-name {
             description "Name of classifier to be applied";
             type string {
               length "1 .. 64";
             }
           }
         }
       }
       leaf forwarding-class {
         description "Forwarding class assigned to incoming Multi-destination packets";
         type string {
         }
       }
     }
   }
   grouping macro-data-type {
     leaf name {
       description "Keyword part of the keyword-value pair";
       type string;
     }
     leaf value {
       description "Value part of the keyword-value pair";
       type string;
     }
   }
 }