submodule Cisco-IOS-XR-ethernet-cfm-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-ethernet-cfm-oper {
        prefix
          Cisco-IOS-XR-ethernet-cfm-oper;
    }

    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR ethernet-cfm package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-10-07" {
      description
        "Added the Link Loss Forwarding feature.";
    }

    revision "2020-07-07" {
      description
        "Added SLA summary information.";
    }

    revision "2019-10-02" {
      description
        "Bandwidth notification addition";
    }

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

    revision "2018-12-20" {
      description
        "Bandwidth notification class and type name update.";
    }

    revision "2017-10-06" {
      description
        "Traceroute transaction ID changed from int to uint.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.3.0";
    semver:module-version "1.2.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Sla-error-string {
      type string;
      description "Sla error string";
    }

    typedef Sla-oper-packet-priority {
      type enumeration {
        enum "priority-none" {
          value 0;
          description
            "Packet does not use any specified priority.";
        }
        enum "priority-cos" {
          value 1;
          description
            "Packet uses a specified 3-bit COS priority
           value.";
        }
      }
      description
        "Priority scheme for packet priority";
    }

    typedef Sla-oper-test-pattern-scheme {
      type enumeration {
        enum "hex" {
          value 0;
          description
            "Packet is padded with a user-specified string";
        }
        enum "pseudo-random" {
          value 1;
          description
            "Packet is padded with a pseudo-random bit
           sequence";
        }
      }
      description
        "Test pattern scheme for packet padding";
    }

    typedef Sla-oper-bucket {
      type enumeration {
        enum "bucket-type-bins" {
          value 0;
          description "SLA metric bin";
        }
        enum "bucket-type-samples" {
          value 1;
          description "SLA metric sample";
        }
      }
      description
        "Type of SLA metric bucket";
    }

    typedef Sla-metric-threshold-state {
      type enumeration {
        enum "threshold-not-breached" {
          value 0;
          description
            "Threshold is not breached";
        }
        enum "threshold-breached-last" {
          value 1;
          description
            "Threshold was breached in the last bucket";
        }
        enum "threshold-breached-current" {
          value 2;
          description
            "Threshold is breached in the current bucket";
        }
      }
      description
        "Sla metric threshold state";
    }

    typedef Sla-cfg-thresh-condition {
      type enumeration {
        enum "condition-maximum" {
          value 0;
          description
            "Breach on maximum value";
        }
        enum "condition-mean" {
          value 1;
          description "Breach on mean value";
        }
        enum "condition-bin-count" {
          value 2;
          description
            "Breach on sample count in bins";
        }
        enum "condition-type-count" {
          value 3;
          description
            "Number of threshold conditions";
        }
      }
      description "Sla cfg thresh condition";
    }

    typedef Sla-cfg-threshold {
      type enumeration {
        enum "stateful-threshold" {
          value 0;
          description "Stateful threshold";
        }
        enum "stateless-threshold" {
          value 1;
          description "Stateless threshold";
        }
        enum "threshold-type-count" {
          value 2;
          description
            "Number of threshold types";
        }
      }
      description "Sla cfg threshold";
    }

    typedef Sla-bucket-size {
      type enumeration {
        enum "buckets-per-probe" {
          value 0;
          description
            "Bucket size is configured as buckets per probe";
        }
        enum "probes-per-bucket" {
          value 1;
          description
            "Bucket size is configured as probes per bucket";
        }
      }
      description
        "Type of configuration of a bucket size";
    }

    typedef Sla-recordable-metric {
      type enumeration {
        enum "metric-invalid" {
          value 0;
          description
            "Not a valid metric type";
        }
        enum "metric-round-trip-delay" {
          value 1;
          description "Round-trip Delay";
        }
        enum "metric-one-way-delay-sd" {
          value 2;
          description
            "One-way Delay (Source->Destination)";
        }
        enum "metric-one-way-delay-ds" {
          value 3;
          description
            "One-way Delay (Destination->Source)";
        }
        enum "metric-round-trip-jitter" {
          value 4;
          description "Round-trip Jitter";
        }
        enum "metric-one-way-jitter-sd" {
          value 5;
          description
            "One-way Jitter (Source->Destination)";
        }
        enum "metric-one-way-jitter-ds" {
          value 6;
          description
            "One-way Jitter (Destination->Source)";
        }
        enum "metric-one-way-flr-sd" {
          value 7;
          description
            "One-way Frame Loss Ratio (Source->Destination)";
        }
        enum "metric-one-way-flr-ds" {
          value 8;
          description
            "One-way Frame Loss Ratio (Destination->Source)";
        }
      }
      description
        "Types of metrics that can be recorded by probes";
    }

    typedef Sla-oper-operation {
      type enumeration {
        enum "operation-type-configured" {
          value 0;
          description
            "Configured SLA operation";
        }
        enum "operation-type-ondemand" {
          value 1;
          description
            "On-demand SLA operation";
        }
      }
      description "Type of SLA operation";
    }

    grouping SLA-OPER-CONFIG-ERRORS {
      description
        "Most recent configuration error information for
       an SLA operation";
      leaf profile-name-xr {
        type string;
        description
          "The name of the operation profile.";
      }

      leaf display-short {
        type string;
        description
          "Short display name used by the operation";
      }

      leaf rt-delay-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect RT Delay
         but the packet type doesn't support it?";
      }

      leaf ow-delay-sd-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect OW Delay
         (SD) but the packet type doesn't support it?";
      }

      leaf ow-delay-ds-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect OW Delay
         (DS) but the packet type doesn't support it?";
      }

      leaf rt-jitter-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect RT Jitter
         but the packet type doesn't support it?";
      }

      leaf ow-jitter-sd-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect OW Jitter
         (SD) but the packet type doesn't support it?";
      }

      leaf ow-jitter-ds-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect OW Delay
         (DS) but the packet type doesn't support it?";
      }

      leaf ow-loss-sd-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect OW Frame
         Loss (SD) but the packet type doesn't support it
         ?";
      }

      leaf ow-loss-ds-inconsistent {
        type boolean;
        description
          "Is the profile configured to collect OW Frame
         Loss (DS) but the packet type doesn't support it
         ?";
      }

      leaf packet-pad-inconsistent {
        type boolean;
        description
          "Is the profile configured to pad packets but the
         packet type doesn't support it?";
      }

      leaf packet-rand-pad-inconsistent {
        type boolean;
        description
          "Is the profile configured to pad packets with a
         pseudo-random string but the packet type doesn't
         support it?";
      }

      leaf min-packet-interval-inconsistent {
        type boolean;
        description
          "Is the profile configured to send packets more
         frequently than the protocol allows?";
      }

      leaf priority-inconsistent {
        type boolean;
        description
          "Is the profile configured to use a packet
         priority scheme that the protocol does not
         support?";
      }

      leaf packet-type-inconsistent {
        type boolean;
        description
          "Is the profile configured to use a packet type
         that isn't supported by any protocols?";
      }

      leaf profile-doesnt-exist {
        type boolean;
        description
          "Is the operation configured to use a profile
         that is not currently defined for the protocol?";
      }

      leaf synthetic-loss-not-supported {
        type boolean;
        description
          "The profile is configured to use a packet type
         which doesn't support synthetic loss measurement
         and the number of packets per FLR calculation
         has been configured";
      }

      leaf probe-too-big {
        type boolean;
        description
          "The profile is configured to use a packet type
         which does not allow more than 72000 packets per
         probe and greater than 72000 packets per probe
         have been configured";
      }

      leaf no-statistics-configured {
        type boolean;
        description
          "Is the profile configured without any statistics
         collection?";
      }

      list error-string {
        description
          "Displays other issues not indicated from the
         flags above, for example MIB incompatibility
         issues.";
        leaf entry {
          type Sla-error-string;
          description
            "Displays other issues not indicated from the
           flags above, for example MIB incompatibility
           issues.";
        }
      }  // list error-string
    }  // grouping SLA-OPER-CONFIG-ERRORS

    grouping SLA-OPER-OPERATION-THRESHOLD {
      description
        "Status for an individual threshold on an
       operation";
      container configuration {
        description
          "Configuration of the threshold";
        uses SLA-CFG-METRIC-THRESH-TYPE;
      }  // container configuration

      leaf action-name {
        type string;
        description
          "Name of the threshold action";
      }
    }  // grouping SLA-OPER-OPERATION-THRESHOLD

    grouping SLA-OPER-OPERATION-METRIC {
      description
        "Status for an individual metric on an operation";
      container metric-config {
        description
          "Configuration of the metric";
        uses SLA-CFG-METRIC-TYPE;
      }  // container metric-config

      leaf current-buckets-archive {
        type uint32;
        description
          "Number of valid buckets currently in the buckets
         archive";
      }

      list threshold {
        description
          "Thresholds configured on the metric";
        uses SLA-OPER-OPERATION-THRESHOLD;
      }  // list threshold
    }  // grouping SLA-OPER-OPERATION-METRIC

    grouping SLA-OPER-PACKET-PRIORITY {
      description
        "Union of available types of packet priority";
      leaf priority-type {
        type Sla-oper-packet-priority;
        description "PriorityType";
      }

      leaf cos {
        when
          "../priority-type = 'priority-cos'" {
          description
            "../PriorityType = 'PriorityCOS'";
        }
        type uint8;
        description
          "3-bit COS priority value applied to packets";
      }
    }  // grouping SLA-OPER-PACKET-PRIORITY

    grouping SLA-OPER-PACKET-PADDING {
      description
        "Parameters of a probe that are only valid if
       packet padding is configured";
      leaf packet-pad-size {
        type uint16;
        description
          "Size that packets are being padded to";
      }

      leaf test-pattern-pad-scheme {
        type Sla-oper-test-pattern-scheme;
        description
          "Test pattern scheme that is used in the packet
         padding";
      }

      leaf test-pattern-pad-hex-string {
        type uint32;
        description
          "Hex string that is used in the packet padding";
      }
    }  // grouping SLA-OPER-PACKET-PADDING

    grouping SLA-OPER-OPERATION-PROFILE {
      description
        "Parameters of an operation that are only valid if
       it has a profile";
      container packet-padding {
        description
          "Configuration of the packet padding";
        uses SLA-OPER-PACKET-PADDING;
      }  // container packet-padding

      container priority {
        description
          "Priority at which to send the packet, if
         configured";
        uses SLA-OPER-PACKET-PRIORITY;
      }  // container priority

      container operation-schedule {
        description "Operation schedule";
        uses SLA-OPER-OPERATION-SCHEDULE;
      }  // container operation-schedule

      leaf probe-type {
        type string;
        description
          "Type of probe used by the operation";
      }

      leaf packets-per-burst {
        type uint16;
        description
          "Number of packets sent per burst";
      }

      leaf inter-packet-interval {
        type uint16;
        units "millisecond";
        description
          "Interval between packets within a burst in
         milliseconds";
      }

      leaf bursts-per-probe {
        type uint32;
        description
          "Number of bursts sent per probe";
      }

      leaf inter-burst-interval {
        type uint32;
        units "millisecond";
        description
          "Interval between bursts within a probe in
         milliseconds";
      }

      leaf flr-calculation-interval {
        type uint32;
        units "millisecond";
        description
          "Interval between FLR calculations for SLM, in
         milliseconds";
      }

      list operation-metric {
        description
          "Array of the metrics that are measured by the
         operation";
        uses SLA-OPER-OPERATION-METRIC;
      }  // list operation-metric
    }  // grouping SLA-OPER-OPERATION-PROFILE

    grouping SLA-OPER-OPERATION {
      description
        "The state of an SLA operation";
      container profile-options {
        description
          "Options that are only valid if the operation has
         a profile";
        uses SLA-OPER-OPERATION-PROFILE;
      }  // container profile-options

      container specific-options {
        description
          "Options specific to the type of operation";
        uses SLA-OPER-OPERATION-SPECIFIC-OPTS;
      }  // container specific-options

      leaf display-short {
        type string;
        description
          "Short display name used by the operation";
      }

      leaf display-long {
        type string;
        description
          "Long display name used by the operation";
      }

      leaf last-run {
        type uint32;
        description
          "Time that the last probe for the operation was
         run, NULL if never run.";
      }
    }  // grouping SLA-OPER-OPERATION

    grouping SLA-OPER-SAMPLE {
      description
        "Contents of an SLA metric sample";
      leaf sent-at {
        type uint32;
        units "millisecond";
        description
          "The time (in milliseconds relative to the start
         time of the bucket) that the sample was sent at";
      }

      leaf sent {
        type boolean;
        description
          "Whether the sample packet was sucessfully sent";
      }

      leaf timed-out {
        type boolean;
        description
          "Whether the sample packet timed out";
      }

      leaf corrupt {
        type boolean;
        description
          "Whether the sample packet was corrupt";
      }

      leaf out-of-order {
        type boolean;
        description
          "Whether the sample packet was received
         out-of-order";
      }

      leaf no-data-packets {
        type boolean;
        description
          "Whether a measurement could not be made because
         no data packets were sent in the sample period.
         Only applicable for LMM measurements";
      }

      leaf result {
        type int32;
        description
          "The result (in microseconds or millionths of a
         percent) of the sample, if available";
      }

      leaf frames-sent {
        type uint32;
        description
          "For FLR measurements, the number of frames sent,
         if available";
      }

      leaf frames-lost {
        type uint32;
        description
          "For FLR measurements, the number of frames lost,
         if available";
      }
    }  // grouping SLA-OPER-SAMPLE

    grouping SLA-OPER-BUCKET-UNAGGREGATED {
      description
        "Result samples in an SLA metric bucket";
      list sample {
        description
          "The samples of an SLA metric bucket";
        uses SLA-OPER-SAMPLE;
      }  // list sample
    }  // grouping SLA-OPER-BUCKET-UNAGGREGATED

    grouping SLA-OPER-BIN {
      description
        "Contents of an SLA metric bin";
      leaf lower-bound {
        type int32;
        description
          "Lower bound (inclusive) of the bin, in
         milliseconds or single units of percent. This
         field is not used for LMM measurements";
      }

      leaf upper-bound {
        type int32;
        description
          "Upper bound (exclusive) of the bin, in
         milliseconds or single units of percent. This
         field is not used for LMM measurements";
      }

      leaf lower-bound-tenths {
        type int32;
        units "percentage";
        description
          "Lower bound (inclusive) of the bin, in tenths of
         percent. This field is only used for LMM
         measurements";
      }

      leaf upper-bound-tenths {
        type int32;
        units "percentage";
        description
          "Upper bound (exclusive) of the bin, in tenths of
         percent. This field is only used for LMM
         measurements";
      }

      leaf sum {
        type int64;
        description
          "The sum of the results in the bin, in
         microseconds or millionths of a percent";
      }

      leaf count {
        type uint32;
        description
          "The total number of results in the bin";
      }
    }  // grouping SLA-OPER-BIN

    grouping SLA-OPER-BUCKET-AGGREGATED {
      description
        "Result bins in an SLA metric bucket";
      list bins {
        description
          "The bins of an SLA metric bucket";
        uses SLA-OPER-BIN;
      }  // list bins
    }  // grouping SLA-OPER-BUCKET-AGGREGATED

    grouping BUCKET-CONTENTS {
      description
        "Contents of an SLA bucket; bins or samples";
      container aggregated {
        when
          "../bucket-type = 'bucket-type-bins'" {
          description
            "../BucketType = 'BucketTypeBins'";
        }
        description
          "Result bins in an SLA metric bucket";
        uses SLA-OPER-BUCKET-AGGREGATED;
      }  // container aggregated

      container unaggregated {
        when
          "../bucket-type = 'bucket-type-samples'" {
          description
            "../BucketType = 'BucketTypeSamples'";
        }
        description
          "Result samples in an SLA metric bucket";
        uses SLA-OPER-BUCKET-UNAGGREGATED;
      }  // container unaggregated

      leaf bucket-type {
        type Sla-oper-bucket;
        description "BucketType";
      }
    }  // grouping BUCKET-CONTENTS

    grouping SLA-OPER-BUCKET {
      description
        "The contents of an SLA bucket";
      container contents {
        description
          "The contents of the bucket; bins or samples";
        uses BUCKET-CONTENTS;
      }  // container contents

      leaf start-at {
        type uint32;
        description
          "Absolute time that the bucket started being
         filled at";
      }

      leaf duration {
        type uint32;
        units "second";
        description
          "Length of time for which the bucket is being
         filled in seconds";
      }

      leaf sent {
        type uint32;
        description
          "Number of packets sent in the probe";
      }

      leaf lost {
        type uint32;
        description
          "Number of lost packets in the probe";
      }

      leaf corrupt {
        type uint32;
        description
          "Number of corrupt packets in the probe";
      }

      leaf out-of-order {
        type uint32;
        description
          "Number of packets recieved out-of-order in the
         probe";
      }

      leaf duplicates {
        type uint32;
        description
          "Number of duplicate packets received in the
         probe";
      }

      leaf minimum {
        type int32;
        description
          "Overall minimum result in the probe, in
         microseconds or millionths of a percent";
      }

      leaf maximum {
        type int32;
        description
          "Overall minimum result in the probe, in
         microseconds or millionths of a percent";
      }

      leaf time-of-minimum {
        type uint32;
        description
          "Absolute time that the minimum value was
         recorded";
      }

      leaf time-of-maximum {
        type uint32;
        description
          "Absolute time that the maximum value was
         recorded";
      }

      leaf average {
        type int32;
        description
          "Mean of the results in the probe, in
         microseconds or millionths of a percent";
      }

      leaf standard-deviation {
        type int32;
        description
          "Standard deviation of the results in the probe,
         in microseconds or millionths of a percent";
      }

      leaf result-count {
        type uint32;
        description
          "The count of samples collected in the bucket.";
      }

      leaf data-sent-count {
        type uint32;
        description
          "The number of data packets sent across the
         bucket, used in the calculation of overall FLR.";
      }

      leaf data-lost-count {
        type uint32;
        description
          "The number of data packets lost across the
         bucket, used in the calculation of overall FLR.";
      }

      leaf overall-flr {
        type int32;
        units "percentage";
        description
          "Frame Loss Ratio across the whole bucket, in
         millionths of a percent";
      }

      leaf suspect-start-mid-bucket {
        type boolean;
        description
          "Results suspect due to a probe starting mid-way
         through a bucket";
      }

      leaf suspect-schedule-latency {
        type boolean;
        description
          "Results suspect due to scheduling latency
         causing one or more packets to not be sent";
      }

      leaf suspect-send-fail {
        type boolean;
        description
          "Results suspect due to failure to send one or
         more packets";
      }

      leaf suspect-premature-end {
        type boolean;
        description
          "Results suspect due to a probe ending
         prematurely";
      }

      leaf suspect-clock-drift {
        type boolean;
        description
          "Results suspect as more than 10 seconds time
         drift detected";
      }

      leaf suspect-memory-allocation-failed {
        type boolean;
        description
          "Results suspect due to a memory allocation
         failure";
      }

      leaf suspect-cleared-mid-bucket {
        type boolean;
        description
          "Results suspect as bucket was cleared mid-way
         through being filled";
      }

      leaf suspect-probe-restarted {
        type boolean;
        description
          "Results suspect as probe restarted mid-way
         through the bucket";
      }

      leaf suspect-management-latency {
        type boolean;
        description
          "Results suspect as processing of results has
         been delayed";
      }

      leaf suspect-multiple-buckets {
        type boolean;
        description
          "Results suspect as the probe has been configured
         across multiple buckets";
      }

      leaf suspect-misordering {
        type boolean;
        description
          "Results suspect as misordering has been detected
         , affecting results";
      }

      leaf suspect-flr-low-packet-count {
        type boolean;
        description
          "Results suspect as FLR calculated based on a low
         packet count";
      }

      leaf premature-reason {
        type uint32;
        description
          "If the probe ended prematurely, the error that
         caused a probe to end";
      }

      leaf premature-reason-string {
        type string;
        description
          "Description of the error code that caused the
         probe to end prematurely. For informational
         purposes only";
      }
    }  // grouping SLA-OPER-BUCKET

    grouping SLA-CFG-METRIC-THRESH-TYPE {
      description
        "Threshold configuration for an individual
       threshold";
      leaf threshold-type {
        type Sla-cfg-threshold;
        description "Type of the threshold";
      }

      leaf threshold-condition {
        type Sla-cfg-thresh-condition;
        description
          "Condition required for the threshold to be
         breached";
      }

      leaf threshold-value {
        type int32;
        description
          "Configured threshold value, above which the
         threshold is breached";
      }

      leaf bin-threshold {
        type uint32;
        description
          "For bin condition thresholds, this gives the bin
         number in and above which samples count towards
         the threshold breach value";
      }
    }  // grouping SLA-CFG-METRIC-THRESH-TYPE

    grouping SLA-OPER-THRESHOLD-STATISTICS {
      description
        "The results gathered for a threshold on a metric";
      container configuration {
        description
          "Configuration of the threshold";
        uses SLA-CFG-METRIC-THRESH-TYPE;
      }  // container configuration

      leaf state {
        type Sla-metric-threshold-state;
        description "State of the threshold";
      }

      leaf breaching-value {
        type int32;
        description
          "The breaching value of the threshold, if
         applicable";
      }

      leaf action-name {
        type string;
        description
          "Name of the threshold action";
      }
    }  // grouping SLA-OPER-THRESHOLD-STATISTICS

    grouping SLA-CFG-METRIC-TYPE {
      description
        "Aggregation configuration for an individual
       metric";
      leaf metric-type {
        type Sla-recordable-metric;
        description
          "Type of metric to which this configuration
         applies";
      }

      leaf bins-count {
        type uint16;
        description
          "Total number of bins into which to aggregate. 0
         if no aggregation.";
      }

      leaf bins-width {
        type uint16;
        description
          "Width of each bin into which to aggregate. 0 if
         no aggregation. For SLM, the units of this value
         are in single units of percent; for LMM they are
         in tenths of percent; for other measurements
         they are in milliseconds.";
      }

      leaf bucket-size {
        type uint8;
        description
          "Size of buckets into which measurements are
         collected";
      }

      leaf bucket-size-unit {
        type Sla-bucket-size;
        description
          "Whether bucket size is 'per-probe' or 'probes'";
      }

      leaf buckets-archive {
        type uint32;
        description
          "Maximum number of buckets to store in memory";
      }
    }  // grouping SLA-CFG-METRIC-TYPE

    grouping SLA-OPER-METRIC-STATISTICS {
      description
        "The results gathered for an individual metric";
      container config {
        description
          "Configuration of the metric";
        uses SLA-CFG-METRIC-TYPE;
      }  // container config

      list threshold {
        description
          "Thresholds on the metric";
        uses SLA-OPER-THRESHOLD-STATISTICS;
      }  // list threshold

      list bucket {
        description
          "Buckets stored for the metric";
        uses SLA-OPER-BUCKET;
      }  // list bucket
    }  // grouping SLA-OPER-METRIC-STATISTICS

    grouping SLA-OPER-OPERATION-SCHEDULE {
      description "Schedule of an operation";
      leaf start-time {
        type uint32;
        units "second";
        description
          "Start time of the first probe, in seconds since
         the Unix Epoch";
      }

      leaf start-time-configured {
        type boolean;
        description
          "Whether or not the operation start time was
         explicitly configured";
      }

      leaf schedule-duration {
        type uint32;
        units "second";
        description
          "Duration of a probe for the operation in seconds";
      }

      leaf schedule-interval {
        type uint32;
        units "second";
        description
          "Interval between the start times of consecutive
         probes,  in seconds.";
      }
    }  // grouping SLA-OPER-OPERATION-SCHEDULE

    grouping SLA-OPER-OD-OPERATION-SPECIFIC {
      description
        "Parameters specific to the state of an ondemand
       operation";
      leaf ondemand-operation-id {
        type uint32;
        description
          "ID of the ondemand operation";
      }

      leaf probe-count {
        type uint8;
        description
          "Total number of probes sent during the operation";
      }
    }  // grouping SLA-OPER-OD-OPERATION-SPECIFIC

    grouping SLA-OPER-CFG-OPERATION-SPECIFIC {
      description
        "Parameters specific to the state of a configured
       operation";
      leaf profile-name {
        type string;
        description
          "Name of the profile used by the operation";
      }
    }  // grouping SLA-OPER-CFG-OPERATION-SPECIFIC

    grouping SLA-OPER-OPERATION-SPECIFIC-OPTS {
      description
        "Parameters specific to the type of SLA operation";
      container configured-operation-options {
        when
          "../oper-type = 'operation-type-configured'" {
          description
            "../OperType = 'OperationTypeConfigured'";
        }
        description
          "Parameters for a configured operation";
        uses SLA-OPER-CFG-OPERATION-SPECIFIC;
      }  // container configured-operation-options

      container ondemand-operation-options {
        when
          "../oper-type = 'operation-type-ondemand'" {
          description
            "../OperType = 'OperationTypeOndemand'";
        }
        description
          "Parameters for an ondemand operation";
        uses SLA-OPER-OD-OPERATION-SPECIFIC;
      }  // container ondemand-operation-options

      leaf oper-type {
        type Sla-oper-operation;
        description "OperType";
      }
    }  // grouping SLA-OPER-OPERATION-SPECIFIC-OPTS

    grouping SLA-OPER-OPERATION-STATISTICS {
      description
        "The statistics of an SLA operation";
      container specific-options {
        description
          "Options specific to the type of operation";
        uses SLA-OPER-OPERATION-SPECIFIC-OPTS;
      }  // container specific-options

      container operation-schedule {
        description "Operation schedule";
        uses SLA-OPER-OPERATION-SCHEDULE;
      }  // container operation-schedule

      leaf probe-type {
        type string;
        description
          "Type of probe used by the operation";
      }

      leaf display-short {
        type string;
        description
          "Short display name used by the operation";
      }

      leaf display-long {
        type string;
        description
          "Long display name used by the operation";
      }

      leaf flr-calculation-interval {
        type uint32;
        units "millisecond";
        description
          "Interval between FLR calculations for SLM, in
         milliseconds";
      }

      list operation-metric {
        description
          "Metrics gathered for the operation";
        uses SLA-OPER-METRIC-STATISTICS;
      }  // list operation-metric
    }  // grouping SLA-OPER-OPERATION-STATISTICS

    grouping SLA-OPER-SUM-INFORMATION {
      description
        "The summary information of SLA operations";
      leaf packet-name {
        type string;
        description
          "The name of the packet type";
      }

      leaf operation-count {
        type uint32;
        description "Number of operations";
      }

      leaf memory-usage {
        type uint64;
        description "Total memory usage";
      }
    }  // grouping SLA-OPER-SUM-INFORMATION

    grouping SLA-OPER-SUMMARY {
      description
        "Summary of SLA operations";
      leaf packets-per-second {
        type uint32;
        description
          "Average packets sent per second across all
         operations";
      }

      list packet-type {
        description
          "Summary of operations information";
        uses SLA-OPER-SUM-INFORMATION;
      }  // list packet-type
    }  // grouping SLA-OPER-SUMMARY
  }  // submodule Cisco-IOS-XR-ethernet-cfm-oper-sub1