submodule openconfig-qos-elements {

    yang-version 1;

    belongs-to openconfig-qos {
        prefix oc-qos;
    }

    import openconfig-extensions {
      prefix oc-ext;
    }
    import openconfig-qos-types {
      prefix oc-qos-types;
    }
    import openconfig-packet-match {
      prefix oc-pkt-match;
    }
    import openconfig-platform {
      prefix oc-platform;
    }
    import openconfig-types {
      prefix oc-types;
    }

    organization "OpenConfig working group";

    contact
      "OpenConfig working group
     www.openconfig.net";

    description
      "This submodule defines configuration and operational state
    data associated with QoS elements.  The primary elements of
    the model include:

      classifiers: match packets with a specific characteristic

      forwarding groups: logical class of packets that receive
      common forwarding treatment

      queues:  collection of packets to be scheduled, including
      a queue management scheme

      schedulers: sequence of one more elements that schedule
      packets for transmission, including policer and shaper
      functions";

    revision "2021-04-28" {
      description
        "Revision updating buffer management and queue management
      configuration.";
      reference
        "0.3.0";

    }

    revision "2019-11-28" {
      description
        "Fix xpaths in when statements";
      reference
        "0.2.3";

    }

    revision "2019-08-20" {
      description
        "Fix typo in classifiers container name";
      reference
        "0.2.2";

    }

    revision "2018-11-21" {
      description
        "Add OpenConfig module metadata extensions.";
      reference
        "0.2.1";

    }

    revision "2016-12-16" {
      description
        "Fix incorrect interface-ref placement";
      reference
        "0.2.0";

    }

    revision "2016-06-03" {
      description "Initial revision";
      reference
        "0.1.0";

    }

    oc-ext:openconfig-version "0.3.0";

    grouping qos-classifier-term-config {
      description
        "Configuration data for list of match criteria in a QoS
      classifier";
      leaf id {
        type string;
        description
          "Identifier for the match term";
      }
    }  // grouping qos-classifier-term-config

    grouping qos-classifier-term-state {
      description
        "Operational state data for list of match criteria in a QoS
      classifier";
    }  // grouping qos-classifier-term-state

    grouping qos-classifier-term-action-config {
      description
        "Configuration parameters for actions for a classifier term.";
      leaf target-group {
        type leafref {
          path
            "../../../../../../../forwarding-groups/forwarding-group/"
              + "config/name";
        }
        description
          "References the forwarding group or class to which the
        matched packets should be assigned";
      }
    }  // grouping qos-classifier-term-action-config

    grouping qos-classifier-terms-top {
      description
        "Top-level grouping for list of match criteria in a QoS
      classifier";
      container terms {
        description
          "Enclosing container for ths list of terms";
        list term {
          key "id";
          description
            "List of match terms used in the classifier";
          leaf id {
            type leafref {
              path "../config/id";
            }
            description
              "Reference to id list key.";
          }

          container config {
            description
              "Configuration data for list of match criteria in a QoS
            classifier";
            uses qos-classifier-term-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for list of match criteria in a
            QoS classifier";
            uses qos-classifier-term-config;

            uses qos-classifier-term-state;
          }  // container state

          container conditions {
            description
              "Conditions for the classifier term. Packets must match all of
            the criteria specified within the match condition to be considered
            matching the term.";
            uses oc-pkt-match:ethernet-header-top;

            uses oc-pkt-match:ipv4-protocol-fields-top;

            uses oc-pkt-match:ipv6-protocol-fields-top;

            uses oc-pkt-match:transport-fields-top;

            uses oc-pkt-match:mpls-header-top;
          }  // container conditions

          container actions {
            description
              "Actions to be applied for packets matching the specified
            classification rules.";
            container config {
              description
                "Actions to be applied to packets that match the classifier
              term.";
              uses qos-classifier-term-action-config;
            }  // container config

            container state {
              config false;
              description
                "Operational state parameters associated with classifier term
              actions";
              uses qos-classifier-term-action-config;
            }  // container state

            container remark {
              description
                "Remark actions to be associated with packets that match the
              classifier term. Where a packet matches these criteria, the
              specified rewrite actions should be performed.";
              uses qos-common-remark-actions;
            }  // container remark
          }  // container actions
        }  // list term
      }  // container terms
    }  // grouping qos-classifier-terms-top

    grouping qos-classifier-config {
      description
        "Configuration data for classifiers";
      leaf name {
        type string;
        description
          "User-assigned name of the classifier";
      }

      leaf type {
        type enumeration {
          enum "IPV4" {
            value 0;
            description
              "Classifier matches and operates
            on packets with IPv4 headers.";
          }
          enum "IPV6" {
            value 1;
            description
              "Classifier matches and operates
            on packets with IPv6 headers.";
          }
          enum "MPLS" {
            value 2;
            description
              "Classifier matches and operates
            on packets with MPLS headers.";
          }
          enum "ETHERNET" {
            value 3;
            description
              "Classifier matches and operates
            on fields within the L2 ETHERNET
            headers.";
          }
        }
        description "Type of classifier.";
      }
    }  // grouping qos-classifier-config

    grouping qos-classifier-state {
      description
        "Operational state data for classifiers";
    }  // grouping qos-classifier-state

    grouping qos-classifier-top {
      description
        "Top-level grouping for classifier data";
      container classifiers {
        description
          "Enclosing container for QoS classifiers";
        list classifier {
          key "name";
          description
            "List of classifier elements";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "Reference to list key name";
          }

          container config {
            description
              "Configuration data for classifers";
            uses qos-classifier-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for classifiers";
            uses qos-classifier-config;

            uses qos-classifier-state;
          }  // container state

          uses qos-classifier-terms-top;
        }  // list classifier
      }  // container classifiers
    }  // grouping qos-classifier-top

    grouping qos-fabric-trace-config {
      description
        "Configuration data for fabric trace data";
      leaf source {
        type leafref {
          path
            "/oc-platform:components/oc-platform:component"
              + "/oc-platform:config/oc-platform:name";
        }
        description
          "Source component for fabric trace data";
      }

      leaf dest {
        type leafref {
          path
            "/oc-platform:components/oc-platform:component"
              + "/oc-platform:config/oc-platform:name";
        }
        description
          "Destination component for fabric trace data";
      }
    }  // grouping qos-fabric-trace-config

    grouping qos-forwarding-group-config {
      description
        "Configuration data for forwarding groups";
      leaf name {
        type string;
        description
          "Name of the forwarding group";
      }

      leaf fabric-priority {
        type uint8;
        description
          "Set the priority for the forwarding group for
        local transmission through the device, e.g.,
        across a switching fabric. Higher priorities
        are considered to be better, such that traffic
        with fabric priority 128 is considered to be
        higher priority than that with fabric priority
        0.";
      }

      leaf output-queue {
        type leafref {
          path
            "../../../../queues/queue/config/name";
        }
        description
          "Output queue for packets in this forwarding group.
        This leaf applies to both multicast and unicast
        packets. Where a user or system requires separate
        queueing for multicast and unicast the unicast-output-queue
        and multicast-output-queue leaves should be specified.";
      }

      leaf unicast-output-queue {
        type leafref {
          path
            "../../../../queues/queue/config/name";
        }
        description
          "Output queue for unicast packets within this
        forwarding group. Where an operator or system does
        not require separate queueing for multicast and
        unicast this leaf is not specified.";
      }

      leaf multicast-output-queue {
        type leafref {
          path
            "../../../../queues/queue/config/name";
        }
        description
          "Output queue for multicast packets within this
        forwarding group. Where an operator or system does
        not require separate queueing for multicast and
        unicast this leaf is not specified.";
      }
    }  // grouping qos-forwarding-group-config

    grouping qos-forwarding-group-state {
      description
        "Operational state data for forwarding groups";
    }  // grouping qos-forwarding-group-state

    grouping qos-forwarding-group-top {
      description
        "Top-level grouping for forwarding group data";
      container forwarding-groups {
        description
          "Enclosing container for list of forwarding groups";
        list forwarding-group {
          key "name";
          description
            "List of forwarding groups.  Forwarding groups are
          logical groups of traffic that will receive common
          forwarding treatment.";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "Reference to name list key";
          }

          container config {
            description
              "Configuration data for forwarding groups";
            uses qos-forwarding-group-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for forwarding groups";
            uses qos-forwarding-group-config;

            uses qos-forwarding-group-state;
          }  // container state
        }  // list forwarding-group
      }  // container forwarding-groups
    }  // grouping qos-forwarding-group-top

    grouping qos-queue-red-common-config {
      description
        "Common configuration parameters applicable to RED and
      its variants";
      leaf enable-ecn {
        type boolean;
        default 'false';
        description
          "When set to true, the device should mark packets that are
        ECN-capable rather than dropping them.  The receiver is
        expected to echo the congestion signal back to the sender
        so that it may adjust its transmission rate accordingly.
        When this leaf is false, the device drops packets according
        to the RED/WRED probability, or all packets if the
        average queue length is above the max threshold.";
      }
    }  // grouping qos-queue-red-common-config

    grouping qos-queue-red-common-state {
      description
        "Common operational state data applicable to RED and
      its variants";
    }  // grouping qos-queue-red-common-state

    grouping qos-queue-wred-config {
      description
        "Configuration data for WRED-managed queues";
    }  // grouping qos-queue-wred-config

    grouping qos-queue-wred-state {
      description
        "Operational state data for WRED-managed queues";
    }  // grouping qos-queue-wred-state

    grouping qos-queue-wred-top {
      description
        "Top-level grouping for WRED-managed queues";
      container wred {
        description
          "Top-level container for WRED data";
        container config {
          description
            "Configuration data for WRED";
          uses qos-queue-wred-config;
        }  // container config

        container state {
          config false;
          description
            "Operational state data for WRED";
          uses qos-queue-wred-config;

          uses qos-queue-wred-state;
        }  // container state
      }  // container wred
    }  // grouping qos-queue-wred-top

    grouping qos-queue-red-config {
      description
        "Configuration data for queues managed with RED";
      leaf minth {
        type uint64;
        units "bytes";
        description
          "The mininum threshold parameter for a RED-managed queue.
        When the average queue length is less than minth, all
        packets are admitted to the queue.";
      }

      leaf maxth {
        type uint64;
        units "bytes";
        description
          "The maximum threshold parameter for a RED-managed queue.
        When the average queue length exceeds the maxth value, all
        packets are dropped (or marked if ECN is enabled).";
      }
    }  // grouping qos-queue-red-config

    grouping qos-queue-red-state {
      description
        "Operational state data for queues managed with RED";
    }  // grouping qos-queue-red-state

    grouping qos-queue-red-top {
      description
        "Top-level grouping for RED queues";
      container red {
        description
          "Top-level container for data related to RED-managed
        queues";
        container config {
          description
            "Configuration data for RED queues";
          uses qos-queue-red-config;
        }  // container config

        container state {
          config false;
          description
            "Operational state data for RED queues";
          uses qos-queue-red-config;

          uses qos-queue-red-state;
        }  // container state
      }  // container red
    }  // grouping qos-queue-red-top

    grouping qos-queue-config {
      description
        "Configuration data for QoS egress queues";
      leaf name {
        type string;
        description
          "User-defined name of the queue";
      }
    }  // grouping qos-queue-config

    grouping qos-queue-state {
      description
        "Operational state data for egress queues";
    }  // grouping qos-queue-state

    grouping qos-queue-top {
      description
        "Top-level grouping for queue elements";
      container queues {
        description
          "Enclosing container for the list of queues";
        list queue {
          key "name";
          description
            "List of defined queues";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "Reference to the queue name list key.";
          }

          container config {
            description
              "Configuration data for queues";
            uses qos-queue-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for queues";
            uses qos-queue-config;

            uses qos-queue-state;
          }  // container state
        }  // list queue
      }  // container queues
    }  // grouping qos-queue-top

    grouping qos-scheduler-output-config {
      description
        "Configuration data for scheduler output operations";
      leaf output-type {
        type enumeration {
          enum "SCHEDULER" {
            value 0;
            description
              "Scheduler output is a child scheduler, e.g. to
            implement hierarchical schedulers.";
          }
          enum "FWD_GROUP" {
            value 1;
            description
              "Scheduler output is a forwarding group, e.g., when
            performing ingress scheduling before packets traverse
            a fabric to be processed by an egress forwarding
            complex.";
          }
          enum "INTERFACE" {
            value 2;
            description
              "Scheduler output is an interface for forwarding.";
          }
        }
        description
          "Describes the type of output sink for the scheduler.";
      }

      leaf child-scheduler {
        when "../output-type = 'SCHEDULER'" {
          description
            "The child-scheduler leaf is valid only when
          the output type of the scheduler is a child scheduler";
        }
        type leafref {
          path
            "../../../../../../../scheduler-policies/scheduler-policy/"
              + "config/name";
        }
        description
          "When the scheduler output type is a child scheduler,
        this leaf provides a reference to the downstream
        scheduler.";
      }

      leaf output-fwd-group {
        when "../output-type = 'FWD_GROUP'" {
          description
            "The output-fwd-group leaf is valid only when
          the output type of the scheduler is a forwarding group";
        }
        type leafref {
          path
            "../../../../../../../forwarding-groups/forwarding-group"
              + "/config/name";
        }
        description
          "When the scheduler output type is a forwarding group,
        this leaf provides a reference to the forwarding group.";
      }
    }  // grouping qos-scheduler-output-config

    grouping qos-scheduler-output-state {
      description
        "Operational state data for scheduler output";
    }  // grouping qos-scheduler-output-state

    grouping qos-scheduler-output-top {
      description
        "Top-level grouping for data related to scheduler output";
      container output {
        description
          "Top-level container for scheduler output data";
        container config {
          description
            "Configuration data for scheduler output";
          uses qos-scheduler-output-config;
        }  // container config

        container state {
          config false;
          description
            "Operational state data for scheduler output";
          uses qos-scheduler-output-config;

          uses qos-scheduler-output-state;
        }  // container state
      }  // container output
    }  // grouping qos-scheduler-output-top

    grouping qos-scheduler-inputs-config {
      description
        "Configuration data for scheduler input sources";
      leaf id {
        type string;
        description
          "User-defined identifier for the scheduler input";
      }

      leaf input-type {
        type enumeration {
          enum "QUEUE" {
            value 0;
            description
              "Input is a defined queue.";
          }
          enum "IN_PROFILE" {
            value 1;
            description
              "Input is in-profile traffic from a parent scheduler/
            shaper";
          }
          enum "OUT_PROFILE" {
            value 2;
            description
              "Input is out-of-profile traffic from a parent
            scheduler/shaper";
          }
        }
        description
          "Describes the type of input source for the scheduler";
      }

      leaf queue {
        when "../input-type = 'QUEUE'" {
          description
            "The queue leaf is valid only when
          the input type of the scheduler is a queue";
        }
        type leafref {
          path
            "../../../../../../../../queues/queue/name";
        }
        description
          "Reference to a queue that is an input source for the
        scheduler";
      }

      leaf weight {
        type uint64;
        description
          "For priority schedulers, this indicates the priority of
        the corresponding input.  Higher values indicate higher
        priority.  For weighted round-robin schedulers, this leaf
        indicates the weight of the corresponding input.";
      }
    }  // grouping qos-scheduler-inputs-config

    grouping qos-scheduler-inputs-state {
      description
        "Operational state data for scheduler input sources";
    }  // grouping qos-scheduler-inputs-state

    grouping qos-scheduler-inputs-top {
      description
        "Top-level grouping for defining inputs to a scheduler.";
      container inputs {
        description "Enclosing container ";
        list input {
          key "id";
          description
            "List of input sources for the scheduler.";
          leaf id {
            type leafref {
              path "../config/id";
            }
            description
              "Reference to list key";
          }

          container config {
            description
              "Configuration data for scheduler input sources";
            uses qos-scheduler-inputs-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state data for scheduler input sources";
            uses qos-scheduler-inputs-config;

            uses qos-scheduler-inputs-state;
          }  // container state
        }  // list input
      }  // container inputs
    }  // grouping qos-scheduler-inputs-top

    grouping qos-scheduler-1r2c-config {
      description
        "Configuration data for 1 rate, 2 color scheduler.";
      leaf cir {
        type uint64;
        units "bps";
        description
          "Committed information rate for the single-rate token
        bucket scheduler.  This value represents the rate at which
        tokens are added to the bucket.";
      }

      leaf cir-pct {
        type oc-types:percentage;
        description
          "Committed information rate for the single-rate token
        bucket scheduler. This value represents the rate at which
        tokens are added to the bucket. It is expressed as a
        percentage of the total bandwidth allocated to the
        context in which the scheduler is referenced.";
      }

      leaf cir-pct-remaining {
        type oc-types:percentage;
        description
          "Committed information rate for the single-rate token
        bucket scheduler. This value represents the rate at which
        tokens are added to the bucket. It is expressed as a
        percentage of the unallocated bandwidth available in the
        context in which the scheduled is referenced.";
      }

      leaf bc {
        type uint32;
        units "bytes";
        description
          "Committed burst size for the single-rate token bucket
        scheduler.  This value represents the depth of the token
        bucket.";
      }

      leaf queuing-behavior {
        type oc-qos-types:queue-behavior;
        description
          "The type of scheduler that is being configured.";
      }

      leaf max-queue-depth-bytes {
        type uint32;
        units "bytes";
        description
          "When the scheduler is specified to be a shaper - the
        maximum depth of the queue in bytes is the value
        specified by this leaf.";
      }

      leaf max-queue-depth-packets {
        type uint32;
        units "packets";
        description
          "When the scheduler is specified to be a shaper - the
        maximum depth of the queue in packets is the value
        specified by this leaf.";
      }

      leaf max-queue-depth-percent {
        type oc-types:percentage;
        description
          "The queue depth specified as a percentage of the total
        available buffer that is avaialble.";
      }
    }  // grouping qos-scheduler-1r2c-config

    grouping qos-scheduler-1r2c-top {
      description
        "Top-level grouping for 1 rate, 2 color shapers";
      container one-rate-two-color {
        description
          "Top-level container for data related to a 1 rate, 2 color
        shaper.";
        container config {
          description
            "Configuration data for 1 rate, 2 color shapers";
          uses qos-scheduler-1r2c-config;
        }  // container config

        container state {
          config false;
          description
            "Operational state data for 1 rate, 2 color shapers";
          uses qos-scheduler-1r2c-config;
        }  // container state

        container conform-action {
          description
            "Action to be applied to packets that are scheduled within the
          CIR of the one-rate, two-colour scheduler. Packets that receive
          a token from the in-CIR bucket are said to be conforming and
          have all of the specified actions applied.";
          container config {
            description
              "Configuration parameters relating to conforming packets for the
            1r2c scheduler.";
            uses qos-common-remark-actions-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to conforming packets
            for the 1r2c scheduler.";
            uses qos-common-remark-actions-config;
          }  // container state
        }  // container conform-action

        container exceed-action {
          description
            "Action to be applied to packets that are scheduled above the CIR
          of the one-rate, two-colour shaper. Packets that do not receive a
          token from the in-CIR bucket are said to be exceeding, and have
          all of the specified actions applied.";
          container config {
            description
              "Configuration parameters relating to exceeding packets for
              the 1r2c scheduler.";
            uses qos-common-remark-actions-config;

            uses qos-common-scheduler-actions-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to exceeding
              packets for the 1r2c scheduler.";
            uses qos-common-remark-actions-config;

            uses qos-common-scheduler-actions-config;
          }  // container state
        }  // container exceed-action
      }  // container one-rate-two-color
    }  // grouping qos-scheduler-1r2c-top

    grouping qos-scheduler-2r3c-config {
      description
        "Configuration data for 2 rate, 3 color policer";
      leaf cir {
        type uint64;
        units "bps";
        description
          "Committed information rate for the dual-rate token
        bucket policer.  This value represents the rate at which
        tokens are added to the primary bucket.";
      }

      leaf cir-pct {
        type oc-types:percentage;
        description
          "Committed information rate for the dual-rate token bucket
        policer. This value represents the rate at which tokens
        are added to the primary bucket. It is expressed as a
        percentage of the total bandwidth available within the
        context the scheduler is instantiated.";
      }

      leaf cir-pct-remaining {
        type oc-types:percentage;
        description
          "Committed information rate for the dual-rate token
        bucket policer. This value represents the rate at which
        tokens are added to the primary bucket. It is expressed
        as a percentage of the remaining bandwidth within the
        context the scheduler is instantiated.";
      }

      leaf pir {
        type uint64;
        units "bps";
        description
          "Peak information rate for the dual-rate token bucket
        policer.  This value represents the rate at which tokens
        are added to the secondary bucket.";
      }

      leaf pir-pct {
        type oc-types:percentage;
        description
          "Peak information rate for the dual-rate token bucket
        policer. This value represents the rate at which tokens
        are added to the secondary bucket. The value is expressed
        as a percentage of the total bandwidth available in the
        context in which the scheduler is instantiated.";
      }

      leaf pir-pct-remaining {
        type oc-types:percentage;
        description
          "Peak information rate for the dual-rate token
        bucket policer. This value represents the rate at which
        tokens are added to the secondary bucket. It is expressed
        as a percentage of the remaining bandwidth within the
        context the scheduler is instantiated.";
      }

      leaf bc {
        type uint32;
        units "bytes";
        description
          "Committed burst size for the dual-rate token bucket
        policer.  This value represents the depth of the token
        bucket.";
      }

      leaf be {
        type uint32;
        units "bytes";
        description
          "Excess burst size for the dual-rate token bucket policer.
        This value represents the depth of the secondary bucket.";
      }
    }  // grouping qos-scheduler-2r3c-config

    grouping qos-scheduler-2r3c-top {
      description
        "Top-level grouping for 2 rate, 3 color policers..";
      container two-rate-three-color {
        description
          "Top-level container for data for a 2 rate, 3 color policer.";
        container config {
          description
            "Configuration data for 2 rate, 3 color policers.";
          uses qos-scheduler-2r3c-config;
        }  // container config

        container state {
          config false;
          description
            "Operational state data for 2 rate, 3 color policers.";
          uses qos-scheduler-2r3c-config;
        }  // container state

        container conform-action {
          description
            "Action to be applied to the packets that are scheduled
          within the CIR of the policer. All packets that receive
          a token from this bucket have all actions specified
          applied to them";
          container config {
            description
              "Configuration parameters for the conform action of a
              2r3c policer.";
            uses qos-common-remark-actions-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to the conform
              action of a 2r3c policer.";
            uses qos-common-remark-actions-config;
          }  // container state
        }  // container conform-action

        container exceed-action {
          description
            "Action to be applied to the packets that are scheduled
          within the PIR of the policer. Packets that receive a
          token from within the PIR allocation have all the
          specified actions applied to them";
          container config {
            description
              "Configuration parameters relating to the action
            applied to exceeding packets.";
            uses qos-common-remark-actions-config;

            uses qos-common-scheduler-actions-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to the action
            applied to exceeding packets.";
            uses qos-common-remark-actions-config;

            uses qos-common-scheduler-actions-config;
          }  // container state
        }  // container exceed-action

        container violate-action {
          description
            "Action to be applied to the packets that are scheduled
          above the PIR of the policer. Packets that do not receive
          a token from either bucket have all specified actions
          applied to them.";
          container config {
            description
              "Configuration parameters relating to the action
            applied to violating packets.";
            uses qos-common-remark-actions-config;

            uses qos-common-scheduler-actions-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to the action
            applied to violating packets.";
            uses qos-common-remark-actions-config;

            uses qos-common-scheduler-actions-config;
          }  // container state
        }  // container violate-action
      }  // container two-rate-three-color
    }  // grouping qos-scheduler-2r3c-top

    grouping qos-scheduler-config {
      description
        "Configuration data for QoS schedulers";
      leaf sequence {
        type uint32;
        description
          "Sequence number for the scheduler within the scheduler
        policy. Schedulers are processed from lowest sequence
        to highest.";
      }

      leaf type {
        type identityref {
          base oc-qos-types:QOS_SCHEDULER_TYPE;
        }
        description
          "Sets the type of scheduler, i.e. the scheduling algorithm
        used to serve inputs.";
      }

      leaf priority {
        type enumeration {
          enum "STRICT" {
            value 0;
            description
              "This scheduler term is considered as a strict priority
            term - such that packets that arrive in the queue are
            immediately serviced.";
          }
        }
        description
          "Priority of the scheduler within the scheduler policy.";
      }
    }  // grouping qos-scheduler-config

    grouping qos-scheduler-state {
      description
        "Operational state data for QoS schedulers";
    }  // grouping qos-scheduler-state

    grouping qos-scheduler-policy-config {
      description
        "Configuration parameters relating to a scheduler policy";
      leaf name {
        type string;
        description
          "Name for the scheduler policy.";
      }
    }  // grouping qos-scheduler-policy-config

    grouping qos-scheduler-top {
      description
        "Top-level grouping for the set of defined QoS schedulers";
      container scheduler-policies {
        description
          "Enclosing container for the list of configured scheduler policies.";
        list scheduler-policy {
          key "name";
          description
            "List of scheduler policies. A scheduler policy is a set of schedulers
          that are to be applied together. Each scheduler within a scheduler
          policy takes an input, and outputs it according to a scheduling
          discipline that is specified within it. The schedulers consume
          resources according to the specification that is provided - which
          may be absolute resource limits, or relative.";
          leaf name {
            type leafref {
              path "../config/name";
            }
            description
              "Reference to the name of the scheduler policy";
          }

          container config {
            description
              "Configuration parameters relating to a scheduler policy.";
            uses qos-scheduler-policy-config;
          }  // container config

          container state {
            config false;
            description
              "Operational state parameters relating to a scheduler policy.";
            uses qos-scheduler-policy-config;
          }  // container state

          container schedulers {
            description
              "Schedulers within the scheduler policy.";
            list scheduler {
              key "sequence";
              description
                "List of defined QoS traffic schedulers.";
              leaf sequence {
                type leafref {
                  path "../config/sequence";
                }
                description
                  "Reference to the list key";
              }

              container config {
                description
                  "Configuration data for QoS schedulers";
                uses qos-scheduler-config;
              }  // container config

              container state {
                config false;
                description
                  "Operational state data for QoS schedulers";
                uses qos-scheduler-config;

                uses qos-scheduler-state;
              }  // container state

              uses qos-scheduler-inputs-top;

              uses qos-scheduler-output-top;

              uses qos-scheduler-1r2c-top;

              uses qos-scheduler-2r3c-top;
            }  // list scheduler
          }  // container schedulers
        }  // list scheduler-policy
      }  // container scheduler-policies
    }  // grouping qos-scheduler-top

    grouping qos-common-remark-actions {
      description
        "Common grouping specifying actions related to re-marking
      packets";
      container config {
        description
          "Configuration parameters relating to remarking packets.";
        uses qos-common-remark-actions-config;
      }  // container config

      container state {
        config false;
        description
          "Operational state parameters relating to remarking packets.";
        uses qos-common-remark-actions-config;
      }  // container state
    }  // grouping qos-common-remark-actions

    grouping qos-common-scheduler-actions-config {
      description
        "Configuration data for common actions of a QoS scheduler.";
      leaf drop {
        type boolean;
        description
          "If set to true, packets within this context are dropped.";
      }
    }  // grouping qos-common-scheduler-actions-config

    grouping qos-common-remark-actions-config {
      description
        "Configuration data for QoS re-marking actions";
      leaf set-dscp {
        type uint8;
        description
          "Sets the 6-bit DSCP (differentiated services code point)
        value in the IP packet header.";
        reference
          "RFC 2474 - Definition of the Differentiated Services Field
          (DS Field) in the IPv4 and IPv6 Headers";

      }

      leaf set-dot1p {
        type uint8;
        description
          "Sets the 3-bit class-of-service value in the
        Ethernet packet header for 802.1Q VLAN-tagged packets,
        also known as PCP (priority code point).";
        reference
          "IEEE 802.1Q-2014 - IEEE Standard for Local and metropolitan
          area networks--Bridges and Bridged Networks";

      }

      leaf set-mpls-tc {
        type uint8;
        description
          "Sets the 3-bit traffic class value (also referred to as EXP
        or CoS) in MPLS packets.";
        reference
          "RFC 3270 - Multi-Protocol Label Switching (MPLS) Support of
          Differentiated Services";

      }
    }  // grouping qos-common-remark-actions-config
  }  // submodule openconfig-qos-elements