submodule Cisco-IOS-XR-pmengine-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-pmengine-oper {
        prefix Cisco-IOS-XR-pmengine-oper;
    }

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    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 pmengine package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-09-02" {
      description
        "Added PM support for PRBS direction feature.
       2020-07-20
         Added parameter for cumulative BIP count in pcs pmengine bag.
       2020-04-17
         Added Instantaneous Q Margin in fec layer.
       2020-04-07
         Changes made to support TCA for OTU PRBS layer.";
    }

    revision "2019-10-10" {
      description
        "Added support for flexible bin.";
    }

    revision "2019-09-30" {
      description
        "Existing optics parameter PMD is deprecated and SOPMD is added to use instead.
       2019-08-28
       Max and Min time support for fec and optics layer parameters.
       2019-06-01
       Added Range attribute for the history buckets.";
    }

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

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

    revision "2017-03-30" {
      description "OTU PRBS Stats Added";
    }

    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 Pm-sonet-path-width-enum {
      type enumeration {
        enum "none" {
          value 0;
          description
            "Sonet Path Width NONE ";
        }
        enum "sts1" {
          value 1;
          description
            "Sonet Path Width STS1 ";
        }
        enum "sts3c-stm1" {
          value 2;
          description
            "Sonet Path Width sts3cSTM1 ";
        }
        enum "sts12c-stm4" {
          value 3;
          description
            "Sonet Path Width sts12cSTM4 ";
        }
        enum "sts24c" {
          value 4;
          description
            "Sonet Path Width sts24 ";
        }
        enum "sts48c-stm16" {
          value 5;
          description
            "Sonet Path Width sts48cSTM16 ";
        }
        enum "sts192c-stm64" {
          value 6;
          description
            "Sonet Path Width sts192cSTM64 ";
        }
        enum "sts768c-stm256" {
          value 7;
          description
            "Sonet Path Width sts768cSTM256 ";
        }
      }
      description "Sonet Path Width Enum";
    }

    typedef Pm-prbs-status-et {
      type enumeration {
        enum "not-applicable" {
          value 0;
          description "not applicable";
        }
        enum "locked" {
          value 1;
          description "locked";
        }
        enum "un-locked" {
          value 2;
          description "unlocked";
        }
      }
      description "PM PRBS Status Mode Enum";
    }

    typedef Pm-prbs-pattern-et {
      type enumeration {
        enum "prbs-none" {
          value 0;
          description "pn none";
        }
        enum "pn31" {
          value 1;
          description "pn31";
        }
        enum "pn23" {
          value 2;
          description "pn23";
        }
        enum "pn11" {
          value 4;
          description "pn11";
        }
        enum "inv-pn31" {
          value 8;
          description "inv pn31";
        }
        enum "inv-pn11" {
          value 16;
          description "inv pn11";
        }
        enum "pn15" {
          value 32;
          description "pn15";
        }
        enum "pn7" {
          value 64;
          description "pn7";
        }
      }
      description
        "PM PRBS Pattern Mode Enum";
    }

    typedef Pm-prbs-direction-et {
      type enumeration {
        enum "none" {
          value 0;
          description "none";
        }
        enum "line" {
          value 1;
          description "line";
        }
        enum "system" {
          value 2;
          description "system";
        }
      }
      description
        "PM PRBS Direction Mode Enum";
    }

    grouping PM-PCS-PARAMETER-COUNT {
      description "pm pcs parameter count";
      leaf name {
        type string {
          length "0..19";
        }
        description "pcs param name";
      }

      leaf data {
        type uint64;
        description
          "the threshold users set";
      }
    }  // grouping PM-PCS-PARAMETER-COUNT

    grouping PM-PCS-PARAMETER {
      description "pm pcs parameter";
      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      list count {
        description "param count";
        uses PM-PCS-PARAMETER-COUNT;
      }  // list count
    }  // grouping PM-PCS-PARAMETER

    grouping PM-PCS-PARAS {
      description "all paras in pcs";
      container bip {
        description "Bip ";
        uses PM-PCS-PARAMETER;
      }  // container bip

      container frm-err {
        description "Frm Err";
        uses PM-PCS-PARAMETER;
      }  // container frm-err

      container bad-sh {
        description "Bad Sh";
        uses PM-PCS-PARAMETER;
      }  // container bad-sh

      container es-ne {
        description "Es Ne";
        uses PM-PCS-PARAMETER;
      }  // container es-ne

      container ses-ne {
        description "Ses Ne";
        uses PM-PCS-PARAMETER;
      }  // container ses-ne

      container uas-ne {
        description "Uas Ne";
        uses PM-PCS-PARAMETER;
      }  // container uas-ne

      container es-fe {
        description "Es Fe";
        uses PM-PCS-PARAMETER;
      }  // container es-fe

      container ses-fe {
        description "Ese Fe";
        uses PM-PCS-PARAMETER;
      }  // container ses-fe

      container uas-fe {
        description "Uas Fe";
        uses PM-PCS-PARAMETER;
      }  // container uas-fe

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string;
        description "timestamp";
      }

      leaf last-clear-time {
        type string;
        description "last clear time";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }

      leaf cumulative-bip {
        type uint64;
        description "Cumulative Bip";
      }
    }  // grouping PM-PCS-PARAS

    grouping PM-OPTICS-PARAMETER-STRING {
      description "one parameter in optics";
      leaf valid {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "valid";
      }

      leaf minimum {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "minimum";
      }

      leaf average {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "average";
      }

      leaf maximum {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "maximum";
      }

      leaf minimum-threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "minimun threshold";
      }

      leaf configured-min-thresh {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "minimunthreshold";
      }

      leaf minimum-tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA on min";
      }

      leaf maximum-threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "maximum threshold";
      }

      leaf configured-max-thresh {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "maximumthreshold";
      }

      leaf maximum-tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA on max";
      }

      leaf min-time {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description "minimum time";
      }

      leaf max-time {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description "maximum time";
      }
    }  // grouping PM-OPTICS-PARAMETER-STRING

    grouping PM-OPTICS-PARAMETER {
      description "one parameter in optics";
      leaf valid {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "valid";
      }

      leaf minimum {
        xr:event-telemetry "Subscribe Telemetry Event";
        type int32;
        description "minimum";
      }

      leaf average {
        xr:event-telemetry "Subscribe Telemetry Event";
        type int32;
        description "average";
      }

      leaf maximum {
        xr:event-telemetry "Subscribe Telemetry Event";
        type int32;
        description "maximum";
      }

      leaf minimum-threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type int32;
        description "minimun threshold";
      }

      leaf configured-min-thresh {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "minimunthreshold";
      }

      leaf minimum-tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA on min";
      }

      leaf maximum-threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type int32;
        description "maximum threshold";
      }

      leaf configured-max-thresh {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "maximumthreshold";
      }

      leaf maximum-tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA on max";
      }

      leaf min-time {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description "minimum time";
      }

      leaf max-time {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description "maximum time";
      }
    }  // grouping PM-OPTICS-PARAMETER

    grouping PM-OPTICS-PARAS {
      description "all paras in optics";
      container lbc {
        description "LBC";
        uses PM-OPTICS-PARAMETER;
      }  // container lbc

      container lbc-pc {
        description "LBC in percentage";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container lbc-pc

      container opt {
        description "OPT";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container opt

      container opr {
        description "OPR";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container opr

      container cd {
        description "Chromatic Dispersion";
        uses PM-OPTICS-PARAMETER;
      }  // container cd

      container dgd {
        description
          "Differential group Delay";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container dgd

      container pmd {
        description
          "Polarization Mode Dispersion , deprecated , use
         sopmd instead which is duplicate of pmd";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container pmd

      container sopmd {
        description
          "Second order Polarization Mode Dispersion";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container sopmd

      container osnr {
        description
          "Optical Signal to Noise Ratio";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container osnr

      container center-wavelength {
        description
          "Center Wavelength/Frequency";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container center-wavelength

      container pdl {
        description
          "Polarization Dependent Loss";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container pdl

      container pcr {
        description
          "Polarization Change Rate";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container pcr

      container pn {
        description "Phase Noise";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container pn

      container rx-sig-pow {
        description "Rx signal power";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container rx-sig-pow

      container low-sig-freq-off {
        description "low freq sig off";
        uses PM-OPTICS-PARAMETER;
      }  // container low-sig-freq-off

      container ampli-gain {
        description "Ampli Gain";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container ampli-gain

      container ampli-gain-tilt {
        description "Ampli Gain Tilt";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container ampli-gain-tilt

      container snr {
        description "SNR";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container snr

      container snrax {
        description "SNR AX";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container snrax

      container snrbx {
        description "SNR BX";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container snrbx

      container snray {
        description "SNR AY";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container snray

      container snrby {
        description "SNR BY";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container snrby

      container sops1 {
        description "SOP S1";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container sops1

      container sops2 {
        description "SOP S2";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container sops2

      container sops3 {
        description "SOP S3";
        uses PM-OPTICS-PARAMETER-STRING;
      }  // container sops3

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "timestamp";
      }

      leaf last-clear-time {
        type string;
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string;
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string;
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string;
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string;
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }
    }  // grouping PM-OPTICS-PARAS

    grouping SONET-FAR-END-LINE-ENTRY {
      description "SONET FAR END LINE ENTRY";
      container far-end-line-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-SONET-PARAMETER;
      }  // container far-end-line-e-ss

      container far-end-line-se-ss {
        description
          "The number of Severely Errored Seconds";
        uses PM-SONET-PARAMETER;
      }  // container far-end-line-se-ss

      container far-end-line-c-vs {
        description
          "The number of Coding Violations";
        uses PM-SONET-PARAMETER;
      }  // container far-end-line-c-vs

      container far-end-line-ua-ss {
        description
          "The number of Unavailable Seconds";
        uses PM-SONET-PARAMETER;
      }  // container far-end-line-ua-ss

      container far-end-line-fc-ls {
        description
          "The number of Failure counts Seconds";
        uses PM-SONET-PARAMETER;
      }  // container far-end-line-fc-ls
    }  // grouping SONET-FAR-END-LINE-ENTRY

    grouping SONET-LINE-ENTRY {
      description "SONET LINE ENTRY";
      container line-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-SONET-PARAMETER;
      }  // container line-e-ss

      container line-se-ss {
        description
          "The number of Severely Errored Seconds";
        uses PM-SONET-PARAMETER;
      }  // container line-se-ss

      container line-c-vs {
        description
          "The number of Coding Violations";
        uses PM-SONET-PARAMETER;
      }  // container line-c-vs

      container line-ua-ss {
        description
          "The number of Unavailable Seconds";
        uses PM-SONET-PARAMETER;
      }  // container line-ua-ss

      container line-fc-ls {
        description
          "The number of Failure counts Seconds";
        uses PM-SONET-PARAMETER;
      }  // container line-fc-ls

      leaf line-status {
        type int32;
        description
          " status of the interface";
      }
    }  // grouping SONET-LINE-ENTRY

    grouping PM-SONET-PARAMETER {
      description "pm one parameter";
      leaf data {
        type uint32;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint32;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-SONET-PARAMETER

    grouping SONET-SECTION-ENTRY {
      description "SONET SECTION ENTRY";
      container section-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-SONET-PARAMETER;
      }  // container section-e-ss

      container section-se-ss {
        description
          "The number of Severely Errored Seconds";
        uses PM-SONET-PARAMETER;
      }  // container section-se-ss

      container section-sef-ss {
        description
          "The number of Severely Errored Framing Seconds";
        uses PM-SONET-PARAMETER;
      }  // container section-sef-ss

      container section-c-vs {
        description
          "The number of Coding Violations";
        uses PM-SONET-PARAMETER;
      }  // container section-c-vs

      leaf section-status {
        type int32;
        description
          " status of the interface";
      }
    }  // grouping SONET-SECTION-ENTRY

    grouping PM-SONET-PARAS {
      description "all paras in ocn";
      container section {
        description "SECTION";
        uses SONET-SECTION-ENTRY;
      }  // container section

      container line {
        description "LINE";
        uses SONET-LINE-ENTRY;
      }  // container line

      container fe-line {
        description "FarEnd LINE";
        uses SONET-FAR-END-LINE-ENTRY;
      }  // container fe-line

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }
    }  // grouping PM-SONET-PARAS

    grouping SONET-FAR-END-PATH-ENTRY {
      description "SONET FAR END PATH ENTRY";
      leaf far-end-path-e-ss {
        type uint32;
        units "second";
        description
          "The number of Errored Seconds";
      }

      leaf far-end-path-se-ss {
        type uint32;
        units "second";
        description
          "The number of Severely Errored Seconds";
      }

      leaf far-end-path-c-vs {
        type uint32;
        description
          "The number of Coding Violations";
      }

      leaf far-end-path-ua-ss {
        type uint32;
        units "second";
        description
          "The number of Unavailable Seconds";
      }
    }  // grouping SONET-FAR-END-PATH-ENTRY

    grouping PM-SONET-PATH-PARAMETER {
      description "pm one parameter";
      leaf data {
        type uint32;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint32;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-SONET-PATH-PARAMETER

    grouping SONET-PATH-ENTRY {
      description "SONET PATH ENTRY";
      container path-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-SONET-PATH-PARAMETER;
      }  // container path-e-ss

      container path-se-ss {
        description
          "The number of Severely Errored Seconds";
        uses PM-SONET-PATH-PARAMETER;
      }  // container path-se-ss

      container path-c-vs {
        description
          "The number of Coding Violations";
        uses PM-SONET-PATH-PARAMETER;
      }  // container path-c-vs

      container path-ua-ss {
        description
          "The number of Unavailable Seconds";
        uses PM-SONET-PATH-PARAMETER;
      }  // container path-ua-ss

      leaf path-width {
        type Pm-sonet-path-width-enum;
        description
          "Indicates the type of the SONET/SDH Path";
      }

      leaf path-status {
        type int32;
        description
          " status of the interface";
      }
    }  // grouping SONET-PATH-ENTRY

    grouping PM-SONET-PATH-PARAS {
      description "all paras in sts";
      container path {
        description "PATH";
        uses SONET-PATH-ENTRY;
      }  // container path

      container fe-path {
        description "Far End PATH";
        uses SONET-FAR-END-PATH-ENTRY;
      }  // container fe-path

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }
    }  // grouping PM-SONET-PATH-PARAS

    grouping STM-FAR-END-LINE-ENTRY {
      description "STM FAR END LINE ENTRY";
      container far-end-line-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-STM-PARAMETER;
      }  // container far-end-line-e-ss

      container far-end-line-es-rs {
        description
          "The number of Errored Seconds Ratio";
        uses PM-STM-PARAMETER-RATIO;
      }  // container far-end-line-es-rs

      container far-end-line-ebb-es {
        description
          "The number of Background Block Errors";
        uses PM-STM-PARAMETER;
      }  // container far-end-line-ebb-es

      container far-end-line-bbe-rs {
        description
          "The number of Background Block Errors";
        uses PM-STM-PARAMETER-RATIO;
      }  // container far-end-line-bbe-rs

      container far-end-line-se-ss {
        description
          "The number of Severely Errored Second";
        uses PM-STM-PARAMETER;
      }  // container far-end-line-se-ss

      container far-end-line-ses-rs {
        description
          "The number of Severely Errored Second Ratio";
        uses PM-STM-PARAMETER-RATIO;
      }  // container far-end-line-ses-rs

      container far-end-line-ua-ss {
        description
          "The number of Unavailable Second";
        uses PM-STM-PARAMETER;
      }  // container far-end-line-ua-ss

      container far-end-line-e-bs {
        description
          "The number of Errored Block Second";
        uses PM-STM-PARAMETER;
      }  // container far-end-line-e-bs
    }  // grouping STM-FAR-END-LINE-ENTRY

    grouping STM-LINE-ENTRY {
      description "STM LINE ENTRY";
      container line-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-STM-PARAMETER;
      }  // container line-e-ss

      container line-es-rs {
        description
          "The number of Errored Seconds Ratio";
        uses PM-STM-PARAMETER-RATIO;
      }  // container line-es-rs

      container line-bb-es {
        description
          "The number of Background Block Errors";
        uses PM-STM-PARAMETER;
      }  // container line-bb-es

      container line-bbe-rs {
        description
          "The number of Background Block Errors";
        uses PM-STM-PARAMETER-RATIO;
      }  // container line-bbe-rs

      container line-se-ss {
        description
          "The number of Severely Errored Second";
        uses PM-STM-PARAMETER;
      }  // container line-se-ss

      container line-ses-rs {
        description
          "The number of Severely Errored Second Ratio";
        uses PM-STM-PARAMETER-RATIO;
      }  // container line-ses-rs

      container line-ua-ss {
        description
          "The number of Unavailable Second";
        uses PM-STM-PARAMETER;
      }  // container line-ua-ss

      container line-e-bs {
        description
          "The number of Errored Block Second";
        uses PM-STM-PARAMETER;
      }  // container line-e-bs

      leaf line-status {
        type int32;
        description
          " status of the interface";
      }
    }  // grouping STM-LINE-ENTRY

    grouping PM-STM-PARAMETER-RATIO {
      description "pm one parameter";
      leaf data {
        type string {
          length "0..8";
        }
        description
          "the number in the interval";
      }

      leaf threshold {
        type string {
          length "0..8";
        }
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-STM-PARAMETER-RATIO

    grouping PM-STM-PARAMETER {
      description "pm one parameter";
      leaf data {
        type uint32;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint32;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-STM-PARAMETER

    grouping STM-SECTION-ENTRY {
      description "STM SECTION ENTRY";
      container section-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-STM-PARAMETER;
      }  // container section-e-ss

      container section-es-rs {
        description
          "The number of Errored Seconds Ratio";
        uses PM-STM-PARAMETER-RATIO;
      }  // container section-es-rs

      container section-bb-es {
        description
          "The number of Background Block Errors";
        uses PM-STM-PARAMETER;
      }  // container section-bb-es

      container section-bbe-rs {
        description
          "The number of Background Block Errors";
        uses PM-STM-PARAMETER-RATIO;
      }  // container section-bbe-rs

      container section-se-ss {
        description
          "The number of Severely Errored Second";
        uses PM-STM-PARAMETER;
      }  // container section-se-ss

      container section-ses-rs {
        description
          "The number of Severely Errored Second Ratio";
        uses PM-STM-PARAMETER-RATIO;
      }  // container section-ses-rs

      container section-ua-ss {
        description
          "The number of Unavailable Second";
        uses PM-STM-PARAMETER;
      }  // container section-ua-ss

      container section-e-bs {
        description
          "The number of Errored Block Second";
        uses PM-STM-PARAMETER;
      }  // container section-e-bs

      leaf section-status {
        type int32;
        description
          " status of the interface";
      }
    }  // grouping STM-SECTION-ENTRY

    grouping PM-STM-PARAS {
      description "all paras in stm";
      container section {
        description "SECTION";
        uses STM-SECTION-ENTRY;
      }  // container section

      container line {
        description "LINE";
        uses STM-LINE-ENTRY;
      }  // container line

      container fe-line {
        description "FarEnd LINE";
        uses STM-FAR-END-LINE-ENTRY;
      }  // container fe-line

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }
    }  // grouping PM-STM-PARAS

    grouping PM-FEC-PARAM-STRING {
      description "pm avg fec parameter";
      leaf minimum {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "minimum";
      }

      leaf average {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "average";
      }

      leaf maximum {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "maximum";
      }

      leaf minimum-threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "minimun threshold";
      }

      leaf minimum-tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA on min";
      }

      leaf maximum-threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "maximum threshold";
      }

      leaf maximum-tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "valid";
      }

      leaf min-time {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description "minimum time";
      }

      leaf max-time {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description "maximum time";
      }
    }  // grouping PM-FEC-PARAM-STRING

    grouping PM-FEC-PARAM {
      description "pm avg fec param";
      leaf data {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description "valid";
      }
    }  // grouping PM-FEC-PARAM

    grouping PM-FEC-PARAS {
      description "all paras in fec";
      container ec-bits {
        description "EC BITS";
        uses PM-FEC-PARAM;
      }  // container ec-bits

      container uc-words {
        description "UC WORDS";
        uses PM-FEC-PARAM;
      }  // container uc-words

      container pre-fec-ber {
        description "Pre FEC BER";
        uses PM-FEC-PARAM-STRING;
      }  // container pre-fec-ber

      container post-fec-ber {
        description "Post FEC BER";
        uses PM-FEC-PARAM-STRING;
      }  // container post-fec-ber

      container q {
        description "Q";
        uses PM-FEC-PARAM-STRING;
      }  // container q

      container qmargin {
        description "Q Margin";
        uses PM-FEC-PARAM-STRING;
      }  // container qmargin

      container qmargin-inst {
        description "Q Margin Instantaneous";
        uses PM-FEC-PARAM-STRING;
      }  // container qmargin-inst

      container ec-words {
        description "EC Words";
        uses PM-FEC-PARAM;
      }  // container ec-words

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        xr:event-telemetry "Subscribe Telemetry Event";
        type string;
        description "timestamp";
      }

      leaf last-clear-time {
        type string;
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string;
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string;
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string;
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string;
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }
    }  // grouping PM-FEC-PARAS

    grouping PM-GFP-PARAM {
      description "PM GFP PARAM";
      leaf data {
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-GFP-PARAM

    grouping PM-GFP-PARAS {
      description "PM GFP PARAS";
      container rx-bit-err {
        description "RX BIT ERR";
        uses PM-GFP-PARAM;
      }  // container rx-bit-err

      container rx-inv-typ {
        description "RX INV TYP";
        uses PM-GFP-PARAM;
      }  // container rx-inv-typ

      container rx-crc {
        description "RX CRC";
        uses PM-GFP-PARAM;
      }  // container rx-crc

      container rx-lfd {
        description "RX LFD";
        uses PM-GFP-PARAM;
      }  // container rx-lfd

      container rx-csf {
        description "RX CSF";
        uses PM-GFP-PARAM;
      }  // container rx-csf

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }
    }  // grouping PM-GFP-PARAS

    grouping PM-OTNSEC-PARAMETER {
      description "otnsec parameter bag";
      leaf data {
        type uint64;
        description "PM data";
      }

      leaf threshold {
        type uint64;
        description "Configured Threshold";
      }

      leaf tca-report {
        type boolean;
        description "Enable/Disable of TCA";
      }
    }  // grouping PM-OTNSEC-PARAMETER

    grouping PM-OTNSEC-PARAS {
      description "pm otnsec statistics";
      container in-blocks {
        description "Frames";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks

      container in-blocks-enc {
        description "Enc Frames";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-enc

      container in-blocks-un-encrypted {
        description "UnEnc Frames";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-un-encrypted

      container in-blocks-protected {
        description "Auth Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-protected

      container in-blocks-un-protected {
        description "UnAuth Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-un-protected

      container in-blocks-sequence-errors {
        description "Trouble";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-sequence-errors

      container in-blocks-replay-errors {
        description "Replay";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-replay-errors

      container in-blocks-auth-errors {
        description "Auth Fail";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-auth-errors

      container in-blocks-zeroed {
        description "Null Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container in-blocks-zeroed

      container out-blocks {
        description "Frames Encrypt";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks

      container out-blocks-enc {
        description "Auth Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks-enc

      container out-blocks-un-encrypted {
        description "UnEnc count";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks-un-encrypted

      container out-blocks-sequence-errors {
        description
          "OutBlocksSequenceErrors";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks-sequence-errors

      container out-blocks-zeroed {
        description "Null Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks-zeroed

      container out-blocks-protected {
        description "Auth Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks-protected

      container out-blocks-un-protected {
        description "UnAuth Count";
        uses PM-OTNSEC-PARAMETER;
      }  // container out-blocks-un-protected

      leaf valid {
        type boolean;
        description "Bucket state";
      }

      leaf index {
        type uint32;
        description "current or history";
      }

      leaf timestamp {
        type string;
        description "Bucket timestamp";
      }

      leaf last-clear-time {
        type string;
        description
          "Last Clearing of Bucket";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }
    }  // grouping PM-OTNSEC-PARAS

    grouping PM-OTN-ALL-CHANS {
      description
        "all channels in otn layer";
      leaf num-chans {
        type uint32;
        description "number of otn channels";
      }

      list otn-all-chans {
        description "otn channels";
        uses PM-OTN-PARAS;
      }  // list otn-all-chans
    }  // grouping PM-OTN-ALL-CHANS

    grouping PM-PRBS-STATUS-PARAMETER {
      description "one parameter in optics";
      leaf valid {
        type boolean;
        description "valid";
      }

      leaf prbs-status {
        type Pm-prbs-status-et;
        description "Prbs Status";
      }
    }  // grouping PM-PRBS-STATUS-PARAMETER

    grouping PM-PRBS-PARAMETER {
      description "one parameter in optics";
      leaf valid {
        type boolean;
        description "valid";
      }

      leaf rcv-patt {
        type Pm-prbs-pattern-et;
        description "RCVD PTRN";
      }
    }  // grouping PM-PRBS-PARAMETER

    grouping PM-PRBS-TCA-PARAMETER {
      description "one parameter in optics";
      leaf threshold {
        xr:event-telemetry "Subscribe Telemetry Event";
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        xr:event-telemetry "Subscribe Telemetry Event";
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-PRBS-TCA-PARAMETER

    grouping PM-PRBS-PARAS {
      description "all paras in prbs";
      container ebc-tca {
        description "EBC TCA";
        uses PM-PRBS-TCA-PARAMETER;
      }  // container ebc-tca

      container found-count-tca {
        description "FOUND COUNT TCA";
        uses PM-PRBS-TCA-PARAMETER;
      }  // container found-count-tca

      container lost-count-tca {
        description "LOST COUNT TCA";
        uses PM-PRBS-TCA-PARAMETER;
      }  // container lost-count-tca

      container rcv-patt {
        description "RCVD PTRN";
        uses PM-PRBS-PARAMETER;
      }  // container rcv-patt

      container prbs-status {
        description "PRBS STATUS";
        uses PM-PRBS-STATUS-PARAMETER;
      }  // container prbs-status

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }

      leaf prbs-direction {
        type Pm-prbs-direction-et;
        description "prbs direction";
      }

      leaf ebc {
        type uint64;
        description "EBC";
      }

      leaf found-count {
        type uint32;
        description "FOUND COUNT";
      }

      leaf lost-count {
        type uint32;
        description "LOST COUNT";
      }

      leaf found-at-time {
        type uint64;
        description "FOUND AT TS";
      }

      leaf lost-at-time {
        type uint64;
        description "LOST AT TS";
      }

      leaf conf-patt {
        type Pm-prbs-pattern-et;
        description "CONFIG PTRN";
      }
    }  // grouping PM-PRBS-PARAS

    grouping PM-OTN-PARAMETER-RATIO {
      description "pm one parameter";
      leaf data {
        type string;
        description
          "the number in the interval";
      }

      leaf threshold {
        type string;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-OTN-PARAMETER-RATIO

    grouping PM-OTN-PARAMETER {
      description "pm one parameter";
      leaf data {
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-OTN-PARAMETER

    grouping PM-OTN-PARAS {
      description "all paras in otn";
      container lbc {
        description "LBC";
        uses PM-OTN-PARAMETER;
      }  // container lbc

      container es-ne {
        description "ES SM NE";
        uses PM-OTN-PARAMETER;
      }  // container es-ne

      container esr-ne {
        description "ESR PM NE";
        uses PM-OTN-PARAMETER-RATIO;
      }  // container esr-ne

      container ses-ne {
        description "SES SM NE";
        uses PM-OTN-PARAMETER;
      }  // container ses-ne

      container sesr-ne {
        description "SESR SM NE";
        uses PM-OTN-PARAMETER-RATIO;
      }  // container sesr-ne

      container uas-ne {
        description "UAS SM NE";
        uses PM-OTN-PARAMETER;
      }  // container uas-ne

      container bbe-ne {
        description "BBE SM NE";
        uses PM-OTN-PARAMETER;
      }  // container bbe-ne

      container bber-ne {
        description "BBER SM NE";
        uses PM-OTN-PARAMETER-RATIO;
      }  // container bber-ne

      container fc-ne {
        description "FC SM NE";
        uses PM-OTN-PARAMETER;
      }  // container fc-ne

      container es-fe {
        description "ES SM FE";
        uses PM-OTN-PARAMETER;
      }  // container es-fe

      container esr-fe {
        description "ESR PM FE";
        uses PM-OTN-PARAMETER-RATIO;
      }  // container esr-fe

      container ses-fe {
        description "SES SM FE";
        uses PM-OTN-PARAMETER;
      }  // container ses-fe

      container sesr-fe {
        description "SESR SM FE";
        uses PM-OTN-PARAMETER-RATIO;
      }  // container sesr-fe

      container uas-fe {
        description "UAS SM FE";
        uses PM-OTN-PARAMETER;
      }  // container uas-fe

      container bbe-fe {
        description "BBE SM FE";
        uses PM-OTN-PARAMETER;
      }  // container bbe-fe

      container bber-fe {
        description "BBER SM FE";
        uses PM-OTN-PARAMETER-RATIO;
      }  // container bber-fe

      container fc-fe {
        description "FC SM FE";
        uses PM-OTN-PARAMETER;
      }  // container fc-fe

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string;
        description "timestamp";
      }

      leaf last-clear-time {
        type string;
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string;
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string;
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string;
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string;
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }
    }  // grouping PM-OTN-PARAS

    grouping HO-VC-FAR-END-PATH-ENTRY {
      description "HO VC FAR END PATH ENTRY";
      leaf far-end-path-e-ss {
        type uint32;
        units "second";
        description
          "The number of Errored Seconds";
      }

      leaf far-end-path-se-ss {
        type uint32;
        units "second";
        description
          "The number of Severely Errored Seconds";
      }

      leaf far-end-path-c-vs {
        type uint32;
        description
          "The number of Coding Violations";
      }

      leaf far-end-path-ua-ss {
        type uint32;
        units "second";
        description
          "The number of Unavailable Seconds";
      }
    }  // grouping HO-VC-FAR-END-PATH-ENTRY

    grouping PM-HO-VC-PARAMETER-RATIO {
      description "pm one parameter";
      leaf data {
        type string {
          length "0..8";
        }
        description
          "the number in the interval";
      }

      leaf threshold {
        type string {
          length "0..8";
        }
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-HO-VC-PARAMETER-RATIO

    grouping PM-HO-VC-PARAMETER {
      description "pm one parameter";
      leaf data {
        type uint32;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint32;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }
    }  // grouping PM-HO-VC-PARAMETER

    grouping HO-VC-ENTRY {
      description "HO VC ENTRY";
      container path-e-ss {
        description
          "The number of Errored Seconds";
        uses PM-HO-VC-PARAMETER;
      }  // container path-e-ss

      container path-es-rs {
        description
          "The number of Errored Seconds";
        uses PM-HO-VC-PARAMETER-RATIO;
      }  // container path-es-rs

      container path-se-ss {
        description
          "The number of Severely Errored Seconds";
        uses PM-HO-VC-PARAMETER;
      }  // container path-se-ss

      container path-ses-rs {
        description
          "The number of Severely Errored Seconds";
        uses PM-HO-VC-PARAMETER-RATIO;
      }  // container path-ses-rs

      container path-e-bs {
        description
          "The number of Errored blocks";
        uses PM-HO-VC-PARAMETER;
      }  // container path-e-bs

      container path-ua-ss {
        description
          "The number of Unavailable Seconds";
        uses PM-HO-VC-PARAMETER;
      }  // container path-ua-ss

      container path-bb-es {
        description
          "The number of background block errors";
        uses PM-HO-VC-PARAMETER;
      }  // container path-bb-es

      container path-bbe-rs {
        description
          "The number of background block errors";
        uses PM-HO-VC-PARAMETER-RATIO;
      }  // container path-bbe-rs

      leaf path-status {
        type int32;
        description
          " status of the interface";
      }
    }  // grouping HO-VC-ENTRY

    grouping PM-HO-VC-PARAS {
      description "all paras in ho_vc";
      container path {
        description "PATH";
        uses HO-VC-ENTRY;
      }  // container path

      container fe-path {
        description "Far End PATH";
        uses HO-VC-FAR-END-PATH-ENTRY;
      }  // container fe-path

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }
    }  // grouping PM-HO-VC-PARAS

    grouping PM-SECY-TX-PARAM {
      description "PM SECY TX PARAM";
      leaf data {
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        type boolean;
        description "valid";
      }
    }  // grouping PM-SECY-TX-PARAM

    grouping PM-SECY-TX-PARAS {
      description "PM SECY TX PARAS";
      container out-pkts-protected {
        description "Out Packets Protected";
        uses PM-SECY-TX-PARAM;
      }  // container out-pkts-protected

      container out-pkts-encrypted {
        description "Out Packets Encrypted";
        uses PM-SECY-TX-PARAM;
      }  // container out-pkts-encrypted

      container out-octets-protected {
        description "Out Octets Protected ";
        uses PM-SECY-TX-PARAM;
      }  // container out-octets-protected

      container out-octets-encrypted {
        description "Out Octets Encrypted";
        uses PM-SECY-TX-PARAM;
      }  // container out-octets-encrypted

      container out-pkts-too-long {
        description "Out Packets Too Long";
        uses PM-SECY-TX-PARAM;
      }  // container out-pkts-too-long

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }

      leaf sample-count {
        type uint64;
        description "Running Sample Count";
      }
    }  // grouping PM-SECY-TX-PARAS

    grouping PM-SECY-RX-PARAM {
      description "PM SECY RX PARAM";
      leaf data {
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        type boolean;
        description "valid";
      }
    }  // grouping PM-SECY-RX-PARAM

    grouping PM-SECY-RX-PARAS {
      description "PM SECY RX PARAS";
      container in-pkts-unchecked {
        description "In Packet Unchecked";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-unchecked

      container in-pkts-delayed {
        description "In Packet Delay";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-delayed

      container in-pkts-late {
        description "In Packet Late";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-late

      container in-pkts-ok {
        description "In Packet Ok";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-ok

      container in-pkts-invalid {
        description "In Packet Invalid";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-invalid

      container in-pkts-not-valid {
        description "In Packet Not Valid";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-not-valid

      container in-pkts-not-using-sa {
        description "In Packet Not Using SA";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-not-using-sa

      container in-pkts-unused-sa {
        description "In Packet Unused SA";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-unused-sa

      container in-pkts-untagged-hit {
        description "In Packet Untagged Hit";
        uses PM-SECY-RX-PARAM;
      }  // container in-pkts-untagged-hit

      container in-octets-validated {
        description "In Octet Validated";
        uses PM-SECY-RX-PARAM;
      }  // container in-octets-validated

      container in-octets-decrypted {
        description "In Octet Decrypted";
        uses PM-SECY-RX-PARAM;
      }  // container in-octets-decrypted

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }

      leaf sample-count {
        type uint64;
        description "Running Sample Count";
      }
    }  // grouping PM-SECY-RX-PARAS

    grouping PM-SECY-IF-PARAM {
      description "PM SECY IF PARAM";
      leaf data {
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        type boolean;
        description "valid";
      }
    }  // grouping PM-SECY-IF-PARAM

    grouping PM-SECY-IF-PARAS {
      description "PM SECY IF PARAS";
      container in-pkts-untagged {
        description "In Packet Untagged";
        uses PM-SECY-IF-PARAM;
      }  // container in-pkts-untagged

      container in-pkts-no-tag {
        description "In Packet No tag";
        uses PM-SECY-IF-PARAM;
      }  // container in-pkts-no-tag

      container in-pkts-bad-tag {
        description "In Packet Bad tag";
        uses PM-SECY-IF-PARAM;
      }  // container in-pkts-bad-tag

      container in-pkts-unknown-sci {
        description "In Packet Unknown sci";
        uses PM-SECY-IF-PARAM;
      }  // container in-pkts-unknown-sci

      container in-pkts-no-sci {
        description "In Packet No sci";
        uses PM-SECY-IF-PARAM;
      }  // container in-pkts-no-sci

      container in-pkts-overrun {
        description "In Packet Overrun";
        uses PM-SECY-IF-PARAM;
      }  // container in-pkts-overrun

      container in-octets-validated {
        description "In Octet Validated";
        uses PM-SECY-IF-PARAM;
      }  // container in-octets-validated

      container in-octets-decrypted {
        description "In Octet Decrypted";
        uses PM-SECY-IF-PARAM;
      }  // container in-octets-decrypted

      container out-pkts-untagged {
        description "Out Packet Untagged";
        uses PM-SECY-IF-PARAM;
      }  // container out-pkts-untagged

      container out-pkts-too-long {
        description "Out Packet Too Long";
        uses PM-SECY-IF-PARAM;
      }  // container out-pkts-too-long

      container out-octets-protected {
        description "Out Octet Protected";
        uses PM-SECY-IF-PARAM;
      }  // container out-octets-protected

      container out-octets-encrypted {
        description "Out Octet encrypted";
        uses PM-SECY-IF-PARAM;
      }  // container out-octets-encrypted

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string {
          length "0..64";
        }
        description "last clear time";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }

      leaf sample-count {
        type uint64;
        description "Running Sample Count";
      }
    }  // grouping PM-SECY-IF-PARAS

    grouping PM-ETHER-PARAM-STRING {
      description "PM ETHER PARAM STRING";
      leaf data {
        type string;
        description
          "the number in the interval";
      }

      leaf threshold {
        type string;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        type boolean;
        description "valid";
      }
    }  // grouping PM-ETHER-PARAM-STRING

    grouping PM-ETHER-PARAM {
      description "PM ETHER PARAM";
      leaf data {
        type uint64;
        description
          "the number in the interval";
      }

      leaf threshold {
        type uint64;
        description
          "the threshold users set";
      }

      leaf tca-report {
        type boolean;
        description
          "enable/disable to report TCA";
      }

      leaf valid {
        type boolean;
        description "valid";
      }
    }  // grouping PM-ETHER-PARAM

    grouping PM-ETHERNET-PARAS {
      description "all paras in ether";
      container rx-pkt {
        description "RX PKT";
        uses PM-ETHER-PARAM;
      }  // container rx-pkt

      container stat-pkt {
        description "STAT PKT";
        uses PM-ETHER-PARAM;
      }  // container stat-pkt

      container octet-stat {
        description "OCTET STAT";
        uses PM-ETHER-PARAM;
      }  // container octet-stat

      container oversize-pkt-stat {
        description "OVERSIZE PKT";
        uses PM-ETHER-PARAM;
      }  // container oversize-pkt-stat

      container fcs-errors-stat {
        description "FCS ERR";
        uses PM-ETHER-PARAM;
      }  // container fcs-errors-stat

      container long-frames-stat {
        description "LONG FRAMES";
        uses PM-ETHER-PARAM;
      }  // container long-frames-stat

      container jabber-stat {
        description "JABBER STATS";
        uses PM-ETHER-PARAM;
      }  // container jabber-stat

      container ether64-octets {
        description "SIXTY FOUR OCTET";
        uses PM-ETHER-PARAM;
      }  // container ether64-octets

      container ether65127-octet {
        description "OCTET";
        uses PM-ETHER-PARAM;
      }  // container ether65127-octet

      container ether128255-octet {
        description "TFF OCTET";
        uses PM-ETHER-PARAM;
      }  // container ether128255-octet

      container ether256511-octet {
        description "FOO OCTET";
        uses PM-ETHER-PARAM;
      }  // container ether256511-octet

      container ether5121023-octet {
        description "OZTT OCTET";
        uses PM-ETHER-PARAM;
      }  // container ether5121023-octet

      container ether10241518-octet {
        description "OFO OCTET";
        uses PM-ETHER-PARAM;
      }  // container ether10241518-octet

      container in-ucast-pkt {
        description "IN UCAST";
        uses PM-ETHER-PARAM;
      }  // container in-ucast-pkt

      container in-mcast-pkt {
        description "IN MCAST";
        uses PM-ETHER-PARAM;
      }  // container in-mcast-pkt

      container in-bcast-pkt {
        description "IN BCAST";
        uses PM-ETHER-PARAM;
      }  // container in-bcast-pkt

      container out-ucast-pkt {
        description "OUT UCAST";
        uses PM-ETHER-PARAM;
      }  // container out-ucast-pkt

      container out-bcast-pkt {
        description "OUT BCAST";
        uses PM-ETHER-PARAM;
      }  // container out-bcast-pkt

      container out-mcast-pkt {
        description "OUT MCAST";
        uses PM-ETHER-PARAM;
      }  // container out-mcast-pkt

      container tx-pkt {
        description "TX PKT";
        uses PM-ETHER-PARAM;
      }  // container tx-pkt

      container if-in-errors {
        description "IFIN ERRORS";
        uses PM-ETHER-PARAM;
      }  // container if-in-errors

      container if-in-octets {
        description "IFIN OCTETS";
        uses PM-ETHER-PARAM;
      }  // container if-in-octets

      container ether-stat-multicast-pkt {
        description
          "ETHER STAT MULTICAST PKT";
        uses PM-ETHER-PARAM;
      }  // container ether-stat-multicast-pkt

      container ether-stat-broadcast-pkt {
        description
          "ETHER STAT BROADCAST PKT";
        uses PM-ETHER-PARAM;
      }  // container ether-stat-broadcast-pkt

      container ether-stat-undersized-pkt {
        description
          "ETHER STAT UNDERSIZED PKT";
        uses PM-ETHER-PARAM;
      }  // container ether-stat-undersized-pkt

      container out-octets {
        description "OUT OCTET";
        uses PM-ETHER-PARAM;
      }  // container out-octets

      container in-pause-frame {
        description "INPUT PAUSE FRAME";
        uses PM-ETHER-PARAM;
      }  // container in-pause-frame

      container in-good-bytes {
        description "INPUT GOOD BYTES";
        uses PM-ETHER-PARAM;
      }  // container in-good-bytes

      container in8021q-frames {
        description "INPUT 802 1Q FRAMES";
        uses PM-ETHER-PARAM;
      }  // container in8021q-frames

      container in-pkts1519-max-octets {
        description
          "INPUT PKTS 1519MAX OCTETS";
        uses PM-ETHER-PARAM;
      }  // container in-pkts1519-max-octets

      container in-good-pkts {
        description "INPUT GOOD PKTS";
        uses PM-ETHER-PARAM;
      }  // container in-good-pkts

      container in-drop-overrun {
        description "INPUT DROP OVERRUN";
        uses PM-ETHER-PARAM;
      }  // container in-drop-overrun

      container in-drop-abort {
        description "INPUT DROP ABORT";
        uses PM-ETHER-PARAM;
      }  // container in-drop-abort

      container in-drop-invalid-vlan {
        description
          "INPUT DROP INVALID VLAN";
        uses PM-ETHER-PARAM;
      }  // container in-drop-invalid-vlan

      container in-drop-invalid-dmac {
        description
          "INPUT DROP INVALID DMAC";
        uses PM-ETHER-PARAM;
      }  // container in-drop-invalid-dmac

      container in-drop-invalid-encap {
        description
          "INPUT DROP INVALID ENCAP";
        uses PM-ETHER-PARAM;
      }  // container in-drop-invalid-encap

      container in-drop-other {
        description "INPUT DROP OTHER";
        uses PM-ETHER-PARAM;
      }  // container in-drop-other

      container in-mib-giant {
        description "INPUT MIB GIANT";
        uses PM-ETHER-PARAM;
      }  // container in-mib-giant

      container in-mib-jabber {
        description "INPUT MIB JABBER";
        uses PM-ETHER-PARAM;
      }  // container in-mib-jabber

      container in-mibcrc {
        description "IN MIB CRC";
        uses PM-ETHER-PARAM;
      }  // container in-mibcrc

      container in-error-collisions {
        description "IN ERROR COLLISIONS";
        uses PM-ETHER-PARAM;
      }  // container in-error-collisions

      container in-error-symbol {
        description "IN ERROR SYMBOL";
        uses PM-ETHER-PARAM;
      }  // container in-error-symbol

      container out-good-bytes {
        description "OUT GOOD BYTES";
        uses PM-ETHER-PARAM;
      }  // container out-good-bytes

      container out8021q-frames {
        description "OUT 802 1Q FRAMES";
        uses PM-ETHER-PARAM;
      }  // container out8021q-frames

      container out-pause-frames {
        description "OUT PAUSE FRAMES";
        uses PM-ETHER-PARAM;
      }  // container out-pause-frames

      container out-pkts1519-max-octets {
        description
          "OUT PKTS 1519 MAX OCTETS";
        uses PM-ETHER-PARAM;
      }  // container out-pkts1519-max-octets

      container out-good-pkts {
        description "OUT GOOD PKTS";
        uses PM-ETHER-PARAM;
      }  // container out-good-pkts

      container out-drop-underrun {
        description "OUT DROP UNDERRUN";
        uses PM-ETHER-PARAM;
      }  // container out-drop-underrun

      container out-drop-abort {
        description "OUT DROP ABORT";
        uses PM-ETHER-PARAM;
      }  // container out-drop-abort

      container out-drop-other {
        description "OUT DROP OTHER";
        uses PM-ETHER-PARAM;
      }  // container out-drop-other

      container out-error-other {
        description "OUT ERROR OTHER";
        uses PM-ETHER-PARAM;
      }  // container out-error-other

      container in-error-giant {
        description "IN ERROR GIANT";
        uses PM-ETHER-PARAM;
      }  // container in-error-giant

      container in-error-runt {
        description "IN ERROR RUNT";
        uses PM-ETHER-PARAM;
      }  // container in-error-runt

      container in-error-jabbers {
        description "IN ERROR JABBERS";
        uses PM-ETHER-PARAM;
      }  // container in-error-jabbers

      container in-error-fragments {
        description "IN ERROR FRAGMENTS";
        uses PM-ETHER-PARAM;
      }  // container in-error-fragments

      container in-error-other {
        description "IN ERROR OTHER";
        uses PM-ETHER-PARAM;
      }  // container in-error-other

      container in-pkt64-octet {
        description "IN PKT 64 OCTET";
        uses PM-ETHER-PARAM;
      }  // container in-pkt64-octet

      container in-pkts65-to127-octets {
        description "IN PKTS 65 127OCTETS";
        uses PM-ETHER-PARAM;
      }  // container in-pkts65-to127-octets

      container in-pkts128-to255-octets {
        description "IN PKTS 128 255 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container in-pkts128-to255-octets

      container in-pkts256-to511-octets {
        description "IN PKTS 256 511 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container in-pkts256-to511-octets

      container in-pkts512-to1023-octets {
        description
          "IN PKTS 512 1023 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container in-pkts512-to1023-octets

      container in-pkts1024-to1518-octets {
        description
          "IN PKTS 1024 1518 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container in-pkts1024-to1518-octets

      container outpkt64octet {
        description "OUT PKT 64 OCTET";
        uses PM-ETHER-PARAM;
      }  // container outpkt64octet

      container out-pkts65127-octets {
        description "OUT PKTS 65 127OCTETS";
        uses PM-ETHER-PARAM;
      }  // container out-pkts65127-octets

      container out-pkts128255-octets {
        description
          "OUT PKTS 128 255 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container out-pkts128255-octets

      container out-pkts256511-octets {
        description
          "OUT PKTS 256 511 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container out-pkts256511-octets

      container out-pkts5121023-octets {
        description
          "OUT PKTS 512 1023 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container out-pkts5121023-octets

      container out-pkts10241518-octets {
        description
          "OUT PKTS 1024 1518 OCTETS";
        uses PM-ETHER-PARAM;
      }  // container out-pkts10241518-octets

      container rx-util {
        description
          "Rx Utilization in Percent";
        uses PM-ETHER-PARAM-STRING;
      }  // container rx-util

      container tx-util {
        description
          "Tx Utilization in Percent";
        uses PM-ETHER-PARAM-STRING;
      }  // container tx-util

      container tx-undersized-pkt {
        description "TX Undersized Pkt";
        uses PM-ETHER-PARAM;
      }  // container tx-undersized-pkt

      container tx-oversized-pkt {
        description "TX Oversized Pkt";
        uses PM-ETHER-PARAM;
      }  // container tx-oversized-pkt

      container tx-fragments {
        description "TX Fragments";
        uses PM-ETHER-PARAM;
      }  // container tx-fragments

      container tx-jabber {
        description "TX Jabber";
        uses PM-ETHER-PARAM;
      }  // container tx-jabber

      container tx-bad-fcs {
        description "TX Bad Fcs";
        uses PM-ETHER-PARAM;
      }  // container tx-bad-fcs

      leaf index {
        type uint32;
        description "index";
      }

      leaf valid {
        type boolean;
        description "valid";
      }

      leaf timestamp {
        type string {
          length "0..64";
        }
        description "timestamp";
      }

      leaf last-clear-time {
        type string;
        description "last clear time";
      }

      leaf last-clear-flex-bin-time {
        type string;
        description "last clear time";
      }

      leaf last-clear30-sec-time {
        type string;
        description "last clear time";
      }

      leaf last-clear15-min-time {
        type string;
        description "last clear time";
      }

      leaf last-clear24-hr-time {
        type string;
        description "last clear time";
      }

      leaf flex-bin-support {
        type boolean;
        description "flex bin support";
      }

      leaf flex-bin-interval {
        type uint16;
        description "flex bin interval";
      }

      leaf sec30-support {
        type boolean;
        description "30 sec support";
      }
    }  // grouping PM-ETHERNET-PARAS
  }  // submodule Cisco-IOS-XR-pmengine-oper-sub1