module Cisco-IOS-XR-pmengine-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-pmengine-oper";

    prefix pmengine-oper;

    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-pmengine-oper-sub1 {
      revision-date "2020-09-02";
    }

    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 module contains a collection of YANG definitions
     for Cisco IOS-XR pmengine package operational data.
     
     This module contains definitions
     for the following management objects:
       performance-management: performace data
       performance-management-history: performace 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";

    container performance-management {
      config false;
      description "performace data";
      container macsec {
        description
          "MACSEC controller performance data";
        container macsec-ports {
          description
            "Port performance data";
          list macsec-port {
            key "name";
            description
              "Port performance data";
            container macsec-prev {
              description
                "port prev performance data";
              container macsec-prev-flex-interval {
                description
                  "port prev performance data";
                container macsec-prev-flex-interval-ether-s {
                  description
                    "port prev performance data";
                  list macsec-prev-flex-interval-ether {
                    key "number";
                    description
                      "port flex-sec ether performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-prev-flex-interval-ether
                }  // container macsec-prev-flex-interval-ether-s

                container macsec-prev-flex-interval-secyifs {
                  description
                    "port prev performance data";
                  list macsec-prev-flex-interval-secyif {
                    key "number";
                    description
                      "port flex-sec secy-if performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-untagged {
                      description
                        "In Packet Untagged";
                      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";
                      }
                    }  // container in-pkts-untagged

                    container in-pkts-no-tag {
                      description
                        "In Packet No tag";
                      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";
                      }
                    }  // container in-pkts-no-tag

                    container in-pkts-bad-tag {
                      description
                        "In Packet Bad tag";
                      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";
                      }
                    }  // container in-pkts-bad-tag

                    container in-pkts-unknown-sci {
                      description
                        "In Packet Unknown sci";
                      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";
                      }
                    }  // container in-pkts-unknown-sci

                    container in-pkts-no-sci {
                      description
                        "In Packet No sci";
                      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";
                      }
                    }  // container in-pkts-no-sci

                    container in-pkts-overrun {
                      description
                        "In Packet Overrun";
                      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";
                      }
                    }  // container in-pkts-overrun

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // container in-octets-decrypted

                    container out-pkts-untagged {
                      description
                        "Out Packet Untagged";
                      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";
                      }
                    }  // container out-pkts-untagged

                    container out-pkts-too-long {
                      description
                        "Out Packet Too Long";
                      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";
                      }
                    }  // container out-pkts-too-long

                    container out-octets-protected {
                      description
                        "Out Octet Protected";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octet encrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-prev-flex-interval-secyif
                }  // container macsec-prev-flex-interval-secyifs

                container macsec-prev-flex-interval-secyrxes {
                  description
                    "port prev performance data";
                  list macsec-prev-flex-interval-secyrx {
                    key "number";
                    description
                      "port flex-sec secy-rx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-unchecked {
                      description
                        "In Packet Unchecked";
                      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";
                      }
                    }  // container in-pkts-unchecked

                    container in-pkts-delayed {
                      description
                        "In Packet Delay";
                      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";
                      }
                    }  // container in-pkts-delayed

                    container in-pkts-late {
                      description
                        "In Packet Late";
                      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";
                      }
                    }  // container in-pkts-late

                    container in-pkts-ok {
                      description
                        "In Packet Ok";
                      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";
                      }
                    }  // container in-pkts-ok

                    container in-pkts-invalid {
                      description
                        "In Packet Invalid";
                      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";
                      }
                    }  // container in-pkts-invalid

                    container in-pkts-not-valid {
                      description
                        "In Packet Not Valid";
                      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";
                      }
                    }  // container in-pkts-not-valid

                    container in-pkts-not-using-sa {
                      description
                        "In Packet Not Using SA";
                      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";
                      }
                    }  // container in-pkts-not-using-sa

                    container in-pkts-unused-sa {
                      description
                        "In Packet Unused SA";
                      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";
                      }
                    }  // container in-pkts-unused-sa

                    container in-pkts-untagged-hit {
                      description
                        "In Packet Untagged Hit";
                      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";
                      }
                    }  // container in-pkts-untagged-hit

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-prev-flex-interval-secyrx
                }  // container macsec-prev-flex-interval-secyrxes

                container macsec-prev-flex-interval-secytxes {
                  description
                    "port prev performance data";
                  list macsec-prev-flex-interval-secytx {
                    key "number";
                    description
                      "port flex-sec secy-tx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container out-pkts-protected {
                      description
                        "Out Packets Protected";
                      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";
                      }
                    }  // container out-pkts-protected

                    container out-pkts-encrypted {
                      description
                        "Out Packets Encrypted";
                      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";
                      }
                    }  // container out-pkts-encrypted

                    container out-octets-protected {
                      description
                        "Out Octets Protected ";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octets Encrypted";
                      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";
                      }
                    }  // container out-octets-encrypted

                    container out-pkts-too-long {
                      description
                        "Out Packets Too Long";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-prev-flex-interval-secytx
                }  // container macsec-prev-flex-interval-secytxes
              }  // container macsec-prev-flex-interval
            }  // container macsec-prev

            container macsec-current {
              description
                "port current performance data";
              container macsec-minute15 {
                description
                  "port current performance data";
                container macsec-minute15secyifs {
                  description
                    "port current performance data";
                  list macsec-minute15secyif {
                    key "number";
                    description
                      "port 15-minute secy-if performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-untagged {
                      description
                        "In Packet Untagged";
                      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";
                      }
                    }  // container in-pkts-untagged

                    container in-pkts-no-tag {
                      description
                        "In Packet No tag";
                      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";
                      }
                    }  // container in-pkts-no-tag

                    container in-pkts-bad-tag {
                      description
                        "In Packet Bad tag";
                      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";
                      }
                    }  // container in-pkts-bad-tag

                    container in-pkts-unknown-sci {
                      description
                        "In Packet Unknown sci";
                      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";
                      }
                    }  // container in-pkts-unknown-sci

                    container in-pkts-no-sci {
                      description
                        "In Packet No sci";
                      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";
                      }
                    }  // container in-pkts-no-sci

                    container in-pkts-overrun {
                      description
                        "In Packet Overrun";
                      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";
                      }
                    }  // container in-pkts-overrun

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // container in-octets-decrypted

                    container out-pkts-untagged {
                      description
                        "Out Packet Untagged";
                      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";
                      }
                    }  // container out-pkts-untagged

                    container out-pkts-too-long {
                      description
                        "Out Packet Too Long";
                      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";
                      }
                    }  // container out-pkts-too-long

                    container out-octets-protected {
                      description
                        "Out Octet Protected";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octet encrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-minute15secyif
                }  // container macsec-minute15secyifs

                container macsec-minute15secyrxes {
                  description
                    "port current performance data";
                  list macsec-minute15secyrx {
                    key "number";
                    description
                      "port 15-minute secy-rx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-unchecked {
                      description
                        "In Packet Unchecked";
                      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";
                      }
                    }  // container in-pkts-unchecked

                    container in-pkts-delayed {
                      description
                        "In Packet Delay";
                      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";
                      }
                    }  // container in-pkts-delayed

                    container in-pkts-late {
                      description
                        "In Packet Late";
                      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";
                      }
                    }  // container in-pkts-late

                    container in-pkts-ok {
                      description
                        "In Packet Ok";
                      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";
                      }
                    }  // container in-pkts-ok

                    container in-pkts-invalid {
                      description
                        "In Packet Invalid";
                      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";
                      }
                    }  // container in-pkts-invalid

                    container in-pkts-not-valid {
                      description
                        "In Packet Not Valid";
                      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";
                      }
                    }  // container in-pkts-not-valid

                    container in-pkts-not-using-sa {
                      description
                        "In Packet Not Using SA";
                      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";
                      }
                    }  // container in-pkts-not-using-sa

                    container in-pkts-unused-sa {
                      description
                        "In Packet Unused SA";
                      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";
                      }
                    }  // container in-pkts-unused-sa

                    container in-pkts-untagged-hit {
                      description
                        "In Packet Untagged Hit";
                      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";
                      }
                    }  // container in-pkts-untagged-hit

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-minute15secyrx
                }  // container macsec-minute15secyrxes

                container macsec-minute15secytxes {
                  description
                    "port current performance data";
                  list macsec-minute15secytx {
                    key "number";
                    description
                      "port 15-minute secy-tx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container out-pkts-protected {
                      description
                        "Out Packets Protected";
                      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";
                      }
                    }  // container out-pkts-protected

                    container out-pkts-encrypted {
                      description
                        "Out Packets Encrypted";
                      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";
                      }
                    }  // container out-pkts-encrypted

                    container out-octets-protected {
                      description
                        "Out Octets Protected ";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octets Encrypted";
                      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";
                      }
                    }  // container out-octets-encrypted

                    container out-pkts-too-long {
                      description
                        "Out Packets Too Long";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-minute15secytx
                }  // container macsec-minute15secytxes

                container macsec-minute15-ether-s {
                  description
                    "port current performance data";
                  list macsec-minute15-ether {
                    key "number";
                    description
                      "port 15-minute ether performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-minute15-ether
                }  // container macsec-minute15-ether-s
              }  // container macsec-minute15

              container macsec-second30 {
                description
                  "port current performance data";
                container macsec-second30secyifs {
                  description
                    "port current performance data";
                  list macsec-second30secyif {
                    key "number";
                    description
                      "port 30-sec secy-if performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-untagged {
                      description
                        "In Packet Untagged";
                      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";
                      }
                    }  // container in-pkts-untagged

                    container in-pkts-no-tag {
                      description
                        "In Packet No tag";
                      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";
                      }
                    }  // container in-pkts-no-tag

                    container in-pkts-bad-tag {
                      description
                        "In Packet Bad tag";
                      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";
                      }
                    }  // container in-pkts-bad-tag

                    container in-pkts-unknown-sci {
                      description
                        "In Packet Unknown sci";
                      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";
                      }
                    }  // container in-pkts-unknown-sci

                    container in-pkts-no-sci {
                      description
                        "In Packet No sci";
                      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";
                      }
                    }  // container in-pkts-no-sci

                    container in-pkts-overrun {
                      description
                        "In Packet Overrun";
                      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";
                      }
                    }  // container in-pkts-overrun

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // container in-octets-decrypted

                    container out-pkts-untagged {
                      description
                        "Out Packet Untagged";
                      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";
                      }
                    }  // container out-pkts-untagged

                    container out-pkts-too-long {
                      description
                        "Out Packet Too Long";
                      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";
                      }
                    }  // container out-pkts-too-long

                    container out-octets-protected {
                      description
                        "Out Octet Protected";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octet encrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-second30secyif
                }  // container macsec-second30secyifs

                container macsec-second30secyrxes {
                  description
                    "port current performance data";
                  list macsec-second30secyrx {
                    key "number";
                    description
                      "port 30-sec secy-rx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-unchecked {
                      description
                        "In Packet Unchecked";
                      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";
                      }
                    }  // container in-pkts-unchecked

                    container in-pkts-delayed {
                      description
                        "In Packet Delay";
                      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";
                      }
                    }  // container in-pkts-delayed

                    container in-pkts-late {
                      description
                        "In Packet Late";
                      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";
                      }
                    }  // container in-pkts-late

                    container in-pkts-ok {
                      description
                        "In Packet Ok";
                      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";
                      }
                    }  // container in-pkts-ok

                    container in-pkts-invalid {
                      description
                        "In Packet Invalid";
                      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";
                      }
                    }  // container in-pkts-invalid

                    container in-pkts-not-valid {
                      description
                        "In Packet Not Valid";
                      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";
                      }
                    }  // container in-pkts-not-valid

                    container in-pkts-not-using-sa {
                      description
                        "In Packet Not Using SA";
                      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";
                      }
                    }  // container in-pkts-not-using-sa

                    container in-pkts-unused-sa {
                      description
                        "In Packet Unused SA";
                      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";
                      }
                    }  // container in-pkts-unused-sa

                    container in-pkts-untagged-hit {
                      description
                        "In Packet Untagged Hit";
                      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";
                      }
                    }  // container in-pkts-untagged-hit

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-second30secyrx
                }  // container macsec-second30secyrxes

                container macsec-second30-ether-s {
                  description
                    "port current performance data";
                  list macsec-second30-ether {
                    key "number";
                    description
                      "port 30-sec ether performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-second30-ether
                }  // container macsec-second30-ether-s

                container macsec-second30secytxes {
                  description
                    "port current performance data";
                  list macsec-second30secytx {
                    key "number";
                    description
                      "port 30-sec secy-tx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container out-pkts-protected {
                      description
                        "Out Packets Protected";
                      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";
                      }
                    }  // container out-pkts-protected

                    container out-pkts-encrypted {
                      description
                        "Out Packets Encrypted";
                      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";
                      }
                    }  // container out-pkts-encrypted

                    container out-octets-protected {
                      description
                        "Out Octets Protected ";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octets Encrypted";
                      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";
                      }
                    }  // container out-octets-encrypted

                    container out-pkts-too-long {
                      description
                        "Out Packets Too Long";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-second30secytx
                }  // container macsec-second30secytxes
              }  // container macsec-second30

              container macsec-flex-interval {
                description
                  "port current performance data";
                container macsec-flex-interval-secyifs {
                  description
                    "port current performance data";
                  list macsec-flex-interval-secyif {
                    key "number";
                    description
                      "port flex-sec secy-if performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-untagged {
                      description
                        "In Packet Untagged";
                      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";
                      }
                    }  // container in-pkts-untagged

                    container in-pkts-no-tag {
                      description
                        "In Packet No tag";
                      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";
                      }
                    }  // container in-pkts-no-tag

                    container in-pkts-bad-tag {
                      description
                        "In Packet Bad tag";
                      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";
                      }
                    }  // container in-pkts-bad-tag

                    container in-pkts-unknown-sci {
                      description
                        "In Packet Unknown sci";
                      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";
                      }
                    }  // container in-pkts-unknown-sci

                    container in-pkts-no-sci {
                      description
                        "In Packet No sci";
                      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";
                      }
                    }  // container in-pkts-no-sci

                    container in-pkts-overrun {
                      description
                        "In Packet Overrun";
                      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";
                      }
                    }  // container in-pkts-overrun

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // container in-octets-decrypted

                    container out-pkts-untagged {
                      description
                        "Out Packet Untagged";
                      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";
                      }
                    }  // container out-pkts-untagged

                    container out-pkts-too-long {
                      description
                        "Out Packet Too Long";
                      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";
                      }
                    }  // container out-pkts-too-long

                    container out-octets-protected {
                      description
                        "Out Octet Protected";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octet encrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-flex-interval-secyif
                }  // container macsec-flex-interval-secyifs

                container macsec-flex-interval-secyrxes {
                  description
                    "port current performance data";
                  list macsec-flex-interval-secyrx {
                    key "number";
                    description
                      "port flex-sec secy-rx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-unchecked {
                      description
                        "In Packet Unchecked";
                      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";
                      }
                    }  // container in-pkts-unchecked

                    container in-pkts-delayed {
                      description
                        "In Packet Delay";
                      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";
                      }
                    }  // container in-pkts-delayed

                    container in-pkts-late {
                      description
                        "In Packet Late";
                      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";
                      }
                    }  // container in-pkts-late

                    container in-pkts-ok {
                      description
                        "In Packet Ok";
                      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";
                      }
                    }  // container in-pkts-ok

                    container in-pkts-invalid {
                      description
                        "In Packet Invalid";
                      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";
                      }
                    }  // container in-pkts-invalid

                    container in-pkts-not-valid {
                      description
                        "In Packet Not Valid";
                      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";
                      }
                    }  // container in-pkts-not-valid

                    container in-pkts-not-using-sa {
                      description
                        "In Packet Not Using SA";
                      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";
                      }
                    }  // container in-pkts-not-using-sa

                    container in-pkts-unused-sa {
                      description
                        "In Packet Unused SA";
                      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";
                      }
                    }  // container in-pkts-unused-sa

                    container in-pkts-untagged-hit {
                      description
                        "In Packet Untagged Hit";
                      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";
                      }
                    }  // container in-pkts-untagged-hit

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-flex-interval-secyrx
                }  // container macsec-flex-interval-secyrxes

                container macsec-flex-interval-ether-s {
                  description
                    "port current performance data";
                  list macsec-flex-interval-ether {
                    key "number";
                    description
                      "port flex-sec ether performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-flex-interval-ether
                }  // container macsec-flex-interval-ether-s

                container macsec-flex-interval-secytxes {
                  description
                    "port current performance data";
                  list macsec-flex-interval-secytx {
                    key "number";
                    description
                      "port flex-sec secy-tx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container out-pkts-protected {
                      description
                        "Out Packets Protected";
                      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";
                      }
                    }  // container out-pkts-protected

                    container out-pkts-encrypted {
                      description
                        "Out Packets Encrypted";
                      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";
                      }
                    }  // container out-pkts-encrypted

                    container out-octets-protected {
                      description
                        "Out Octets Protected ";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octets Encrypted";
                      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";
                      }
                    }  // container out-octets-encrypted

                    container out-pkts-too-long {
                      description
                        "Out Packets Too Long";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-flex-interval-secytx
                }  // container macsec-flex-interval-secytxes
              }  // container macsec-flex-interval

              container macsec-hour24 {
                description
                  "port current performance data";
                container macsec-hour24-ether-s {
                  description
                    "port current performance data";
                  list macsec-hour24-ether {
                    key "number";
                    description
                      "port 24 hour ether performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-hour24-ether
                }  // container macsec-hour24-ether-s

                container macsec-hour24secyifs {
                  description
                    "port current performance data";
                  list macsec-hour24secyif {
                    key "number";
                    description
                      "port 24 hour secy-if performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-untagged {
                      description
                        "In Packet Untagged";
                      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";
                      }
                    }  // container in-pkts-untagged

                    container in-pkts-no-tag {
                      description
                        "In Packet No tag";
                      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";
                      }
                    }  // container in-pkts-no-tag

                    container in-pkts-bad-tag {
                      description
                        "In Packet Bad tag";
                      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";
                      }
                    }  // container in-pkts-bad-tag

                    container in-pkts-unknown-sci {
                      description
                        "In Packet Unknown sci";
                      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";
                      }
                    }  // container in-pkts-unknown-sci

                    container in-pkts-no-sci {
                      description
                        "In Packet No sci";
                      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";
                      }
                    }  // container in-pkts-no-sci

                    container in-pkts-overrun {
                      description
                        "In Packet Overrun";
                      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";
                      }
                    }  // container in-pkts-overrun

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // container in-octets-decrypted

                    container out-pkts-untagged {
                      description
                        "Out Packet Untagged";
                      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";
                      }
                    }  // container out-pkts-untagged

                    container out-pkts-too-long {
                      description
                        "Out Packet Too Long";
                      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";
                      }
                    }  // container out-pkts-too-long

                    container out-octets-protected {
                      description
                        "Out Octet Protected";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octet encrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-hour24secyif
                }  // container macsec-hour24secyifs

                container macsec-hour24secyrxes {
                  description
                    "port current performance data";
                  list macsec-hour24secyrx {
                    key "number";
                    description
                      "port 24 hour secy-rx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-pkts-unchecked {
                      description
                        "In Packet Unchecked";
                      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";
                      }
                    }  // container in-pkts-unchecked

                    container in-pkts-delayed {
                      description
                        "In Packet Delay";
                      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";
                      }
                    }  // container in-pkts-delayed

                    container in-pkts-late {
                      description
                        "In Packet Late";
                      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";
                      }
                    }  // container in-pkts-late

                    container in-pkts-ok {
                      description
                        "In Packet Ok";
                      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";
                      }
                    }  // container in-pkts-ok

                    container in-pkts-invalid {
                      description
                        "In Packet Invalid";
                      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";
                      }
                    }  // container in-pkts-invalid

                    container in-pkts-not-valid {
                      description
                        "In Packet Not Valid";
                      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";
                      }
                    }  // container in-pkts-not-valid

                    container in-pkts-not-using-sa {
                      description
                        "In Packet Not Using SA";
                      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";
                      }
                    }  // container in-pkts-not-using-sa

                    container in-pkts-unused-sa {
                      description
                        "In Packet Unused SA";
                      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";
                      }
                    }  // container in-pkts-unused-sa

                    container in-pkts-untagged-hit {
                      description
                        "In Packet Untagged Hit";
                      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";
                      }
                    }  // container in-pkts-untagged-hit

                    container in-octets-validated {
                      description
                        "In Octet Validated";
                      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";
                      }
                    }  // container in-octets-validated

                    container in-octets-decrypted {
                      description
                        "In Octet Decrypted";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-hour24secyrx
                }  // container macsec-hour24secyrxes

                container macsec-hour24secytxes {
                  description
                    "port current performance data";
                  list macsec-hour24secytx {
                    key "number";
                    description
                      "port 24 hour secy-tx performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container out-pkts-protected {
                      description
                        "Out Packets Protected";
                      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";
                      }
                    }  // container out-pkts-protected

                    container out-pkts-encrypted {
                      description
                        "Out Packets Encrypted";
                      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";
                      }
                    }  // container out-pkts-encrypted

                    container out-octets-protected {
                      description
                        "Out Octets Protected ";
                      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";
                      }
                    }  // container out-octets-protected

                    container out-octets-encrypted {
                      description
                        "Out Octets Encrypted";
                      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";
                      }
                    }  // container out-octets-encrypted

                    container out-pkts-too-long {
                      description
                        "Out Packets Too Long";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list macsec-hour24secytx
                }  // container macsec-hour24secytxes
              }  // container macsec-hour24
            }  // container macsec-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list macsec-port
        }  // container macsec-ports
      }  // container macsec

      container ho-vc {
        description
          "HO_VC controller performance data";
        container ho-vc-ports {
          description
            "Port performance data";
          list ho-vc-port {
            key "name";
            description
              "Port performance data";
            container ho-vc-current {
              description
                "port current performance data";
              container ho-vc-hour24 {
                description
                  "port current performance data";
                container ho-vc-hour24-paths {
                  description
                    "port current performance data";
                  list ho-vc-hour24-path {
                    key "number";
                    description
                      "port 24 hour Path performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container path {
                      description "PATH";
                      container path-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-e-ss

                      container path-es-rs {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-es-rs

                      container path-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-se-ss

                      container path-ses-rs {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-ses-rs

                      container path-e-bs {
                        description
                          "The number of Errored blocks";
                        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";
                        }
                      }  // container path-e-bs

                      container path-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container path-ua-ss

                      container path-bb-es {
                        description
                          "The number of background block errors";
                        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";
                        }
                      }  // container path-bb-es

                      container path-bbe-rs {
                        description
                          "The number of background block errors";
                        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";
                        }
                      }  // container path-bbe-rs

                      leaf path-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container path

                    container fe-path {
                      description
                        "Far End PATH";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ho-vc-hour24-path
                }  // container ho-vc-hour24-paths
              }  // container ho-vc-hour24

              container ho-vc-minute15 {
                description
                  "port current performance data";
                container ho-vc-minute15-paths {
                  description
                    "port current performance data";
                  list ho-vc-minute15-path {
                    key "number";
                    description
                      "port 15-minute Path performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container path {
                      description "PATH";
                      container path-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-e-ss

                      container path-es-rs {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-es-rs

                      container path-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-se-ss

                      container path-ses-rs {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-ses-rs

                      container path-e-bs {
                        description
                          "The number of Errored blocks";
                        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";
                        }
                      }  // container path-e-bs

                      container path-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container path-ua-ss

                      container path-bb-es {
                        description
                          "The number of background block errors";
                        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";
                        }
                      }  // container path-bb-es

                      container path-bbe-rs {
                        description
                          "The number of background block errors";
                        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";
                        }
                      }  // container path-bbe-rs

                      leaf path-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container path

                    container fe-path {
                      description
                        "Far End PATH";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ho-vc-minute15-path
                }  // container ho-vc-minute15-paths
              }  // container ho-vc-minute15
            }  // container ho-vc-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list ho-vc-port
        }  // container ho-vc-ports
      }  // container ho-vc

      container odu {
        description
          "ODU controller performance data";
        container odu-ports {
          description
            "Port performance data";
          list odu-port {
            key "name";
            description
              "Port performance data";
            container odu-prev {
              description
                "port prev performance data";
              container odu-prev-flex-interval {
                description
                  "port prev performance data";
                container odu-prev-flex-interval-otns {
                  description
                    "port prev performance data";
                  list odu-prev-flex-interval-otn {
                    key "number";
                    description
                      "port flex-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-prev-flex-interval-otn
                }  // container odu-prev-flex-interval-otns

                container odu-prev-flex-interval-prbses {
                  description
                    "port prev performance data";
                  list odu-prev-flex-interval-prbs {
                    key "number";
                    description
                      "port flex-sec prbs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list odu-prev-flex-interval-prbs
                }  // container odu-prev-flex-interval-prbses

                container odu-prev-flex-interval-otn-all-table {
                  description
                    "port flex-sec otn all channels performance
                   data";
                  leaf num-chans {
                    type uint32;
                    description
                      "number of otn channels";
                  }

                  list otn-all-chans {
                    description
                      "otn channels";
                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otn-all-chans
                }  // container odu-prev-flex-interval-otn-all-table

                container odu-prev-flex-interval-otnsecs {
                  description
                    "flex-sec odu performance data";
                  list odu-prev-flex-interval-otnsec {
                    key "number";
                    description
                      "otnsec flex-sec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-blocks {
                      description "Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks

                    container in-blocks-enc {
                      description
                        "Enc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-enc

                    container in-blocks-un-encrypted {
                      description
                        "UnEnc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-encrypted

                    container in-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-protected

                    container in-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-protected

                    container in-blocks-sequence-errors {
                      description "Trouble";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-sequence-errors

                    container in-blocks-replay-errors {
                      description "Replay";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-replay-errors

                    container in-blocks-auth-errors {
                      description
                        "Auth Fail";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-auth-errors

                    container in-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-zeroed

                    container out-blocks {
                      description
                        "Frames Encrypt";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks

                    container out-blocks-enc {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-enc

                    container out-blocks-un-encrypted {
                      description
                        "UnEnc count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-un-encrypted

                    container out-blocks-sequence-errors {
                      description
                        "OutBlocksSequenceErrors";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-sequence-errors

                    container out-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-zeroed

                    container out-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-protected

                    container out-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // 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";
                    }
                  }  // list odu-prev-flex-interval-otnsec
                }  // container odu-prev-flex-interval-otnsecs

                container odu-prev-flex-interval-gfps {
                  description
                    "port prev performance data";
                  list odu-prev-flex-interval-gfp {
                    key "number";
                    description
                      "port flex-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-bit-err {
                      description
                        "RX BIT ERR";
                      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";
                      }
                    }  // container rx-bit-err

                    container rx-inv-typ {
                      description
                        "RX INV TYP";
                      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";
                      }
                    }  // container rx-inv-typ

                    container rx-crc {
                      description "RX CRC";
                      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";
                      }
                    }  // container rx-crc

                    container rx-lfd {
                      description "RX LFD";
                      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";
                      }
                    }  // container rx-lfd

                    container rx-csf {
                      description "RX CSF";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-prev-flex-interval-gfp
                }  // container odu-prev-flex-interval-gfps
              }  // container odu-prev-flex-interval
            }  // container odu-prev

            container odu-current {
              description
                "port current performance data";
              container odu-minute15 {
                description
                  "port current performance data";
                container odu-minute15gfps {
                  description
                    "port current performance data";
                  list odu-minute15gfp {
                    key "number";
                    description
                      "port 15-minute otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-bit-err {
                      description
                        "RX BIT ERR";
                      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";
                      }
                    }  // container rx-bit-err

                    container rx-inv-typ {
                      description
                        "RX INV TYP";
                      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";
                      }
                    }  // container rx-inv-typ

                    container rx-crc {
                      description "RX CRC";
                      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";
                      }
                    }  // container rx-crc

                    container rx-lfd {
                      description "RX LFD";
                      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";
                      }
                    }  // container rx-lfd

                    container rx-csf {
                      description "RX CSF";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-minute15gfp
                }  // container odu-minute15gfps

                container odu-minute15prbses {
                  description
                    "port current performance data";
                  list odu-minute15prbs {
                    key "number";
                    description
                      "port 15-minute prbs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list odu-minute15prbs
                }  // container odu-minute15prbses

                container odu-minute15otnsecs {
                  description
                    "15-min odu performance data";
                  list odu-minute15otnsec {
                    key "number";
                    description
                      "otnsec 15-min performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-blocks {
                      description "Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks

                    container in-blocks-enc {
                      description
                        "Enc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-enc

                    container in-blocks-un-encrypted {
                      description
                        "UnEnc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-encrypted

                    container in-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-protected

                    container in-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-protected

                    container in-blocks-sequence-errors {
                      description "Trouble";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-sequence-errors

                    container in-blocks-replay-errors {
                      description "Replay";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-replay-errors

                    container in-blocks-auth-errors {
                      description
                        "Auth Fail";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-auth-errors

                    container in-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-zeroed

                    container out-blocks {
                      description
                        "Frames Encrypt";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks

                    container out-blocks-enc {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-enc

                    container out-blocks-un-encrypted {
                      description
                        "UnEnc count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-un-encrypted

                    container out-blocks-sequence-errors {
                      description
                        "OutBlocksSequenceErrors";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-sequence-errors

                    container out-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-zeroed

                    container out-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-protected

                    container out-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // 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";
                    }
                  }  // list odu-minute15otnsec
                }  // container odu-minute15otnsecs

                container odu-minute15otns {
                  description
                    "port current performance data";
                  list odu-minute15otn {
                    key "number";
                    description
                      "port 15-minute otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-minute15otn
                }  // container odu-minute15otns
              }  // container odu-minute15

              container odu-flex-interval {
                description
                  "port current performance data";
                container odu-flex-interval-prbses {
                  description
                    "port current performance data";
                  list odu-flex-interval-prbs {
                    key "number";
                    description
                      "port flex-sec prbs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list odu-flex-interval-prbs
                }  // container odu-flex-interval-prbses

                container odu-flex-interval-gfps {
                  description
                    "port current performance data";
                  list odu-flex-interval-gfp {
                    key "number";
                    description
                      "port flex-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-bit-err {
                      description
                        "RX BIT ERR";
                      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";
                      }
                    }  // container rx-bit-err

                    container rx-inv-typ {
                      description
                        "RX INV TYP";
                      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";
                      }
                    }  // container rx-inv-typ

                    container rx-crc {
                      description "RX CRC";
                      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";
                      }
                    }  // container rx-crc

                    container rx-lfd {
                      description "RX LFD";
                      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";
                      }
                    }  // container rx-lfd

                    container rx-csf {
                      description "RX CSF";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-flex-interval-gfp
                }  // container odu-flex-interval-gfps

                container odu-flex-interval-otns {
                  description
                    "port current performance data";
                  list odu-flex-interval-otn {
                    key "number";
                    description
                      "port flex-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-flex-interval-otn
                }  // container odu-flex-interval-otns

                container odu-flex-interval-otnsecs {
                  description
                    "flex-sec odu performance data";
                  list odu-flex-interval-otnsec {
                    key "number";
                    description
                      "otnsec flexi-sec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-blocks {
                      description "Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks

                    container in-blocks-enc {
                      description
                        "Enc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-enc

                    container in-blocks-un-encrypted {
                      description
                        "UnEnc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-encrypted

                    container in-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-protected

                    container in-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-protected

                    container in-blocks-sequence-errors {
                      description "Trouble";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-sequence-errors

                    container in-blocks-replay-errors {
                      description "Replay";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-replay-errors

                    container in-blocks-auth-errors {
                      description
                        "Auth Fail";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-auth-errors

                    container in-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-zeroed

                    container out-blocks {
                      description
                        "Frames Encrypt";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks

                    container out-blocks-enc {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-enc

                    container out-blocks-un-encrypted {
                      description
                        "UnEnc count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-un-encrypted

                    container out-blocks-sequence-errors {
                      description
                        "OutBlocksSequenceErrors";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-sequence-errors

                    container out-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-zeroed

                    container out-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-protected

                    container out-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // 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";
                    }
                  }  // list odu-flex-interval-otnsec
                }  // container odu-flex-interval-otnsecs
              }  // container odu-flex-interval

              container odu-second30 {
                description
                  "port current performance data";
                container odu-second30prbses {
                  description
                    "30-sec odu performance data";
                  list odu-second30prbs {
                    key "number";
                    description
                      "PRBS 30-sec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list odu-second30prbs
                }  // container odu-second30prbses

                container odu-second30otns {
                  description
                    "30-sec odu performance data";
                  list odu-second30otn {
                    key "number";
                    description
                      "port 30-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-second30otn
                }  // container odu-second30otns

                container odu-second30otnsecs {
                  description
                    "30-sec odu performance data";
                  list odu-second30otnsec {
                    key "number";
                    description
                      "otnsec 30-sec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-blocks {
                      description "Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks

                    container in-blocks-enc {
                      description
                        "Enc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-enc

                    container in-blocks-un-encrypted {
                      description
                        "UnEnc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-encrypted

                    container in-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-protected

                    container in-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-protected

                    container in-blocks-sequence-errors {
                      description "Trouble";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-sequence-errors

                    container in-blocks-replay-errors {
                      description "Replay";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-replay-errors

                    container in-blocks-auth-errors {
                      description
                        "Auth Fail";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-auth-errors

                    container in-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-zeroed

                    container out-blocks {
                      description
                        "Frames Encrypt";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks

                    container out-blocks-enc {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-enc

                    container out-blocks-un-encrypted {
                      description
                        "UnEnc count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-un-encrypted

                    container out-blocks-sequence-errors {
                      description
                        "OutBlocksSequenceErrors";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-sequence-errors

                    container out-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-zeroed

                    container out-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-protected

                    container out-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // 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";
                    }
                  }  // list odu-second30otnsec
                }  // container odu-second30otnsecs

                container odu-second30gfps {
                  description
                    "30-sec odu performance data";
                  list odu-second30gfp {
                    key "number";
                    description
                      "GFP 30-sec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-bit-err {
                      description
                        "RX BIT ERR";
                      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";
                      }
                    }  // container rx-bit-err

                    container rx-inv-typ {
                      description
                        "RX INV TYP";
                      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";
                      }
                    }  // container rx-inv-typ

                    container rx-crc {
                      description "RX CRC";
                      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";
                      }
                    }  // container rx-crc

                    container rx-lfd {
                      description "RX LFD";
                      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";
                      }
                    }  // container rx-lfd

                    container rx-csf {
                      description "RX CSF";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-second30gfp
                }  // container odu-second30gfps
              }  // container odu-second30

              container odu-hour24 {
                description
                  "port current performance data";
                container odu-hour24prbses {
                  description
                    "port 24 hour performance data";
                  list odu-hour24prbs {
                    key "number";
                    description
                      "port 24 hour otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list odu-hour24prbs
                }  // container odu-hour24prbses

                container odu-hour24otnsecs {
                  description
                    "24-hr odu performance data";
                  list odu-hour24otnsec {
                    key "number";
                    description
                      "otnsec 24-hr performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container in-blocks {
                      description "Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks

                    container in-blocks-enc {
                      description
                        "Enc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-enc

                    container in-blocks-un-encrypted {
                      description
                        "UnEnc Frames";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-encrypted

                    container in-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-protected

                    container in-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-un-protected

                    container in-blocks-sequence-errors {
                      description "Trouble";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-sequence-errors

                    container in-blocks-replay-errors {
                      description "Replay";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-replay-errors

                    container in-blocks-auth-errors {
                      description
                        "Auth Fail";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-auth-errors

                    container in-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container in-blocks-zeroed

                    container out-blocks {
                      description
                        "Frames Encrypt";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks

                    container out-blocks-enc {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-enc

                    container out-blocks-un-encrypted {
                      description
                        "UnEnc count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-un-encrypted

                    container out-blocks-sequence-errors {
                      description
                        "OutBlocksSequenceErrors";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-sequence-errors

                    container out-blocks-zeroed {
                      description
                        "Null Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-zeroed

                    container out-blocks-protected {
                      description
                        "Auth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // container out-blocks-protected

                    container out-blocks-un-protected {
                      description
                        "UnAuth Count";
                      leaf data {
                        type uint64;
                        description
                          "PM data";
                      }

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

                      leaf tca-report {
                        type boolean;
                        description
                          "Enable/Disable of TCA";
                      }
                    }  // 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";
                    }
                  }  // list odu-hour24otnsec
                }  // container odu-hour24otnsecs

                container odu-hour24gfps {
                  description
                    "port 24 hour performance data";
                  list odu-hour24gfp {
                    key "number";
                    description
                      "port 24 hour otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-bit-err {
                      description
                        "RX BIT ERR";
                      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";
                      }
                    }  // container rx-bit-err

                    container rx-inv-typ {
                      description
                        "RX INV TYP";
                      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";
                      }
                    }  // container rx-inv-typ

                    container rx-crc {
                      description "RX CRC";
                      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";
                      }
                    }  // container rx-crc

                    container rx-lfd {
                      description "RX LFD";
                      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";
                      }
                    }  // container rx-lfd

                    container rx-csf {
                      description "RX CSF";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-hour24gfp
                }  // container odu-hour24gfps

                container odu-hour24otns {
                  description
                    "port 24 hour performance data";
                  list odu-hour24otn {
                    key "number";
                    description
                      "port 24 hour otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list odu-hour24otn
                }  // container odu-hour24otns
              }  // container odu-hour24
            }  // container odu-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list odu-port
        }  // container odu-ports
      }  // container odu

      container otu {
        description
          "OTU controller performance data";
        container otu-ports {
          description
            "Port performance data";
          list otu-port {
            key "name";
            description
              "Port performance data";
            container otu-prev {
              description
                "port prev performance data";
              container otu-prev-flex-interval {
                description
                  "port prev performance data";
                container otu-prev-flex-interval-fecs {
                  description
                    "port prev performance data";
                  list otu-prev-flex-interval-fec {
                    key "number";
                    description
                      "port flex-sec fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-prev-flex-interval-fec
                }  // container otu-prev-flex-interval-fecs

                container otu-prev-flex-interval-prbses {
                  description
                    "port current performance data";
                  list otu-prev-flex-interval-prbs {
                    key "number";
                    description
                      "port flex-sec prbs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list otu-prev-flex-interval-prbs
                }  // container otu-prev-flex-interval-prbses

                container otu-prev-flex-interval-otns {
                  description
                    "port prev performance data";
                  list otu-prev-flex-interval-otn {
                    key "number";
                    description
                      "port flex-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-prev-flex-interval-otn
                }  // container otu-prev-flex-interval-otns
              }  // container otu-prev-flex-interval
            }  // container otu-prev

            container otu-current {
              description
                "port current performance data";
              container otu-minute15 {
                description
                  "port current performance data";
                container otu-minute15fecs {
                  description
                    "port current performance data";
                  list otu-minute15fec {
                    key "number";
                    description
                      "port 15-minute fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-minute15fec
                }  // container otu-minute15fecs

                container otu-minute15otns {
                  description
                    "port current performance data";
                  list otu-minute15otn {
                    key "number";
                    description
                      "port 15-minute otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-minute15otn
                }  // container otu-minute15otns

                container otu-minute15prbses {
                  description
                    "port current performance data";
                  list otu-minute15prbs {
                    key "number";
                    description
                      "port 15-minute prbs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list otu-minute15prbs
                }  // container otu-minute15prbses
              }  // container otu-minute15

              container otu-second30 {
                description
                  "port current performance data";
                container otu-second30fecs {
                  description
                    "port current performance data";
                  list otu-second30fec {
                    key "number";
                    description
                      "port 30-sec fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-second30fec
                }  // container otu-second30fecs

                container otu-second30otns {
                  description
                    "port current performance data";
                  list otu-second30otn {
                    key "number";
                    description
                      "port 30-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-second30otn
                }  // container otu-second30otns

                container otu-second30prbses {
                  description
                    "prbs 30-sec performance data";
                  list otu-second30prbs {
                    key "number";
                    description
                      "prbs 30-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list otu-second30prbs
                }  // container otu-second30prbses
              }  // container otu-second30

              container otu-flex-interval {
                description
                  "port current performance data";
                container otu-flex-interval-prbses {
                  description
                    "port current performance data";
                  list otu-flex-interval-prbs {
                    key "number";
                    description
                      "port flex-sec prbs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list otu-flex-interval-prbs
                }  // container otu-flex-interval-prbses

                container otu-flex-interval-fecs {
                  description
                    "port current performance data";
                  list otu-flex-interval-fec {
                    key "number";
                    description
                      "port flex-sec fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-flex-interval-fec
                }  // container otu-flex-interval-fecs

                container otu-flex-interval-otns {
                  description
                    "port current performance data";
                  list otu-flex-interval-otn {
                    key "number";
                    description
                      "port flex-sec otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-flex-interval-otn
                }  // container otu-flex-interval-otns
              }  // container otu-flex-interval

              container otu-hour24 {
                description
                  "port current performance data";
                container otu-hour24fecs {
                  description
                    "port current performance data";
                  list otu-hour24fec {
                    key "number";
                    description
                      "port 24 hour fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-hour24fec
                }  // container otu-hour24fecs

                container otu-hour24prbses {
                  description
                    "port 24 hour performance data";
                  list otu-hour24prbs {
                    key "number";
                    description
                      "port 24 hour otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ebc-tca {
                      description "EBC TCA";
                      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";
                      }
                    }  // container ebc-tca

                    container found-count-tca {
                      description
                        "FOUND COUNT TCA";
                      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";
                      }
                    }  // container found-count-tca

                    container lost-count-tca {
                      description
                        "LOST COUNT TCA";
                      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";
                      }
                    }  // container lost-count-tca

                    container rcv-patt {
                      description
                        "RCVD PTRN";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf rcv-patt {
                        type Pm-prbs-pattern-et;
                        description
                          "RCVD PTRN";
                      }
                    }  // container rcv-patt

                    container prbs-status {
                      description
                        "PRBS STATUS";
                      leaf valid {
                        type boolean;
                        description "valid";
                      }

                      leaf prbs-status {
                        type Pm-prbs-status-et;
                        description
                          "Prbs Status";
                      }
                    }  // 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";
                    }
                  }  // list otu-hour24prbs
                }  // container otu-hour24prbses

                container otu-hour24otns {
                  description
                    "port 24 hour performance data";
                  list otu-hour24otn {
                    key "number";
                    description
                      "port 24 hour otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list otu-hour24otn
                }  // container otu-hour24otns
              }  // container otu-hour24
            }  // container otu-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list otu-port
        }  // container otu-ports
      }  // container otu

      container stm {
        description
          "STM controller performance data";
        container stm-ports {
          description
            "Port performance data";
          list stm-port {
            key "name";
            description
              "Port performance data";
            container stm-current {
              description
                "port current performance data";
              container stm-hour24 {
                description
                  "port current performance data";
                container stm-hour24stms {
                  description
                    "port current performance data";
                  list stm-hour24stm {
                    key "number";
                    description
                      "port 24 hour stm performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container section {
                      description "SECTION";
                      container section-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container section-e-ss

                      container section-es-rs {
                        description
                          "The number of Errored Seconds Ratio";
                        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";
                        }
                      }  // container section-es-rs

                      container section-bb-es {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container section-bb-es

                      container section-bbe-rs {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container section-bbe-rs

                      container section-se-ss {
                        description
                          "The number of Severely Errored Second";
                        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";
                        }
                      }  // container section-se-ss

                      container section-ses-rs {
                        description
                          "The number of Severely Errored Second Ratio";
                        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";
                        }
                      }  // container section-ses-rs

                      container section-ua-ss {
                        description
                          "The number of Unavailable Second";
                        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";
                        }
                      }  // container section-ua-ss

                      container section-e-bs {
                        description
                          "The number of Errored Block Second";
                        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";
                        }
                      }  // container section-e-bs

                      leaf section-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container section

                    container line {
                      description "LINE";
                      container line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container line-e-ss

                      container line-es-rs {
                        description
                          "The number of Errored Seconds Ratio";
                        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";
                        }
                      }  // container line-es-rs

                      container line-bb-es {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container line-bb-es

                      container line-bbe-rs {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container line-bbe-rs

                      container line-se-ss {
                        description
                          "The number of Severely Errored Second";
                        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";
                        }
                      }  // container line-se-ss

                      container line-ses-rs {
                        description
                          "The number of Severely Errored Second Ratio";
                        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";
                        }
                      }  // container line-ses-rs

                      container line-ua-ss {
                        description
                          "The number of Unavailable Second";
                        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";
                        }
                      }  // container line-ua-ss

                      container line-e-bs {
                        description
                          "The number of Errored Block Second";
                        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";
                        }
                      }  // container line-e-bs

                      leaf line-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container line

                    container fe-line {
                      description
                        "FarEnd LINE";
                      container far-end-line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-e-ss

                      container far-end-line-es-rs {
                        description
                          "The number of Errored Seconds Ratio";
                        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";
                        }
                      }  // container far-end-line-es-rs

                      container far-end-line-ebb-es {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container far-end-line-ebb-es

                      container far-end-line-bbe-rs {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container far-end-line-bbe-rs

                      container far-end-line-se-ss {
                        description
                          "The number of Severely Errored Second";
                        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";
                        }
                      }  // container far-end-line-se-ss

                      container far-end-line-ses-rs {
                        description
                          "The number of Severely Errored Second Ratio";
                        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";
                        }
                      }  // container far-end-line-ses-rs

                      container far-end-line-ua-ss {
                        description
                          "The number of Unavailable Second";
                        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";
                        }
                      }  // container far-end-line-ua-ss

                      container far-end-line-e-bs {
                        description
                          "The number of Errored Block Second";
                        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";
                        }
                      }  // container far-end-line-e-bs
                    }  // 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";
                    }
                  }  // list stm-hour24stm
                }  // container stm-hour24stms
              }  // container stm-hour24

              container stm-minute15 {
                description
                  "port current performance data";
                container stm-minute15stms {
                  description
                    "port current performance data";
                  list stm-minute15stm {
                    key "number";
                    description
                      "port 15-minute stm performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container section {
                      description "SECTION";
                      container section-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container section-e-ss

                      container section-es-rs {
                        description
                          "The number of Errored Seconds Ratio";
                        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";
                        }
                      }  // container section-es-rs

                      container section-bb-es {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container section-bb-es

                      container section-bbe-rs {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container section-bbe-rs

                      container section-se-ss {
                        description
                          "The number of Severely Errored Second";
                        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";
                        }
                      }  // container section-se-ss

                      container section-ses-rs {
                        description
                          "The number of Severely Errored Second Ratio";
                        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";
                        }
                      }  // container section-ses-rs

                      container section-ua-ss {
                        description
                          "The number of Unavailable Second";
                        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";
                        }
                      }  // container section-ua-ss

                      container section-e-bs {
                        description
                          "The number of Errored Block Second";
                        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";
                        }
                      }  // container section-e-bs

                      leaf section-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container section

                    container line {
                      description "LINE";
                      container line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container line-e-ss

                      container line-es-rs {
                        description
                          "The number of Errored Seconds Ratio";
                        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";
                        }
                      }  // container line-es-rs

                      container line-bb-es {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container line-bb-es

                      container line-bbe-rs {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container line-bbe-rs

                      container line-se-ss {
                        description
                          "The number of Severely Errored Second";
                        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";
                        }
                      }  // container line-se-ss

                      container line-ses-rs {
                        description
                          "The number of Severely Errored Second Ratio";
                        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";
                        }
                      }  // container line-ses-rs

                      container line-ua-ss {
                        description
                          "The number of Unavailable Second";
                        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";
                        }
                      }  // container line-ua-ss

                      container line-e-bs {
                        description
                          "The number of Errored Block Second";
                        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";
                        }
                      }  // container line-e-bs

                      leaf line-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container line

                    container fe-line {
                      description
                        "FarEnd LINE";
                      container far-end-line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-e-ss

                      container far-end-line-es-rs {
                        description
                          "The number of Errored Seconds Ratio";
                        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";
                        }
                      }  // container far-end-line-es-rs

                      container far-end-line-ebb-es {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container far-end-line-ebb-es

                      container far-end-line-bbe-rs {
                        description
                          "The number of Background Block Errors";
                        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";
                        }
                      }  // container far-end-line-bbe-rs

                      container far-end-line-se-ss {
                        description
                          "The number of Severely Errored Second";
                        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";
                        }
                      }  // container far-end-line-se-ss

                      container far-end-line-ses-rs {
                        description
                          "The number of Severely Errored Second Ratio";
                        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";
                        }
                      }  // container far-end-line-ses-rs

                      container far-end-line-ua-ss {
                        description
                          "The number of Unavailable Second";
                        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";
                        }
                      }  // container far-end-line-ua-ss

                      container far-end-line-e-bs {
                        description
                          "The number of Errored Block Second";
                        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";
                        }
                      }  // container far-end-line-e-bs
                    }  // 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";
                    }
                  }  // list stm-minute15stm
                }  // container stm-minute15stms
              }  // container stm-minute15
            }  // container stm-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list stm-port
        }  // container stm-ports
      }  // container stm

      container sonet {
        description
          "SONET controller performance data";
        container sonet-ports {
          description
            "Port performance data";
          list sonet-port {
            key "name";
            description
              "Port performance data";
            container sonet-current {
              description
                "port current performance data";
              container sonet-minute15 {
                description
                  "port current performance data";
                container sonet-minute15-paths {
                  description
                    "port current performance data";
                  list sonet-minute15-path {
                    key "number";
                    description
                      "port 15-minute Path performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container path {
                      description "PATH";
                      container path-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-e-ss

                      container path-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-se-ss

                      container path-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container path-c-vs

                      container path-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // 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";
                      }
                    }  // container path

                    container fe-path {
                      description
                        "Far End PATH";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list sonet-minute15-path
                }  // container sonet-minute15-paths

                container sonet-minute15ocns {
                  description
                    "port current performance data";
                  list sonet-minute15ocn {
                    key "number";
                    description
                      "port 15-minute ocn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container section {
                      description "SECTION";
                      container section-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container section-e-ss

                      container section-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container section-se-ss

                      container section-sef-ss {
                        description
                          "The number of Severely Errored Framing Seconds";
                        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";
                        }
                      }  // container section-sef-ss

                      container section-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container section-c-vs

                      leaf section-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container section

                    container line {
                      description "LINE";
                      container line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container line-e-ss

                      container line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container line-se-ss

                      container line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container line-c-vs

                      container line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container line-ua-ss

                      container line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container line-fc-ls

                      leaf line-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container line

                    container fe-line {
                      description
                        "FarEnd LINE";
                      container far-end-line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-e-ss

                      container far-end-line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-se-ss

                      container far-end-line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container far-end-line-c-vs

                      container far-end-line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container far-end-line-ua-ss

                      container far-end-line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container far-end-line-fc-ls
                    }  // 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";
                    }
                  }  // list sonet-minute15ocn
                }  // container sonet-minute15ocns
              }  // container sonet-minute15

              container sonet-hour24 {
                description
                  "port current performance data";
                container sonet-hour24ocns {
                  description
                    "port current performance data";
                  list sonet-hour24ocn {
                    key "number";
                    description
                      "port 24 hour ocn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container section {
                      description "SECTION";
                      container section-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container section-e-ss

                      container section-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container section-se-ss

                      container section-sef-ss {
                        description
                          "The number of Severely Errored Framing Seconds";
                        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";
                        }
                      }  // container section-sef-ss

                      container section-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container section-c-vs

                      leaf section-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container section

                    container line {
                      description "LINE";
                      container line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container line-e-ss

                      container line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container line-se-ss

                      container line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container line-c-vs

                      container line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container line-ua-ss

                      container line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container line-fc-ls

                      leaf line-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container line

                    container fe-line {
                      description
                        "FarEnd LINE";
                      container far-end-line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-e-ss

                      container far-end-line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-se-ss

                      container far-end-line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container far-end-line-c-vs

                      container far-end-line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container far-end-line-ua-ss

                      container far-end-line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container far-end-line-fc-ls
                    }  // 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";
                    }
                  }  // list sonet-hour24ocn
                }  // container sonet-hour24ocns

                container sonet-hour24-paths {
                  description
                    "port current performance data";
                  list sonet-hour24-path {
                    key "number";
                    description
                      "port 24 hour Path performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container path {
                      description "PATH";
                      container path-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-e-ss

                      container path-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-se-ss

                      container path-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container path-c-vs

                      container path-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // 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";
                      }
                    }  // container path

                    container fe-path {
                      description
                        "Far End PATH";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list sonet-hour24-path
                }  // container sonet-hour24-paths
              }  // container sonet-hour24
            }  // container sonet-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list sonet-port
        }  // container sonet-ports
      }  // container sonet

      container optics {
        description
          "OPTICS controller performance data";
        container optics-ports {
          description
            "Port performance data";
          list optics-port {
            key "name";
            description
              "Port performance data";
            container optics-current {
              description
                "port current performance data";
              container optics-flex-interval {
                description
                  "port current performance data";
                container optics-flex-interval-fecs {
                  description
                    "port current performance data";
                  list optics-flex-interval-fec {
                    key "number";
                    description
                      "port variable-second fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-flex-interval-fec
                }  // container optics-flex-interval-fecs

                container optics-flex-interval-optics {
                  description
                    "port current performance data";
                  list optics-flex-interval-optic {
                    key "number";
                    description
                      "port variable-second optics performance
                     data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-flex-interval-optic
                }  // container optics-flex-interval-optics
              }  // container optics-flex-interval

              container optics-hour24 {
                description
                  "port current performance data";
                container optics-hour24-optics {
                  description
                    "port 24 hour performance data";
                  list optics-hour24-optic {
                    key "number";
                    description
                      "port 24 hour optics performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-hour24-optic
                }  // container optics-hour24-optics

                container optics-hour24fecs {
                  description
                    "port current performance data";
                  list optics-hour24fec {
                    key "number";
                    description
                      "port 24 hour fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-hour24fec
                }  // container optics-hour24fecs
              }  // container optics-hour24

              container optics-minute15 {
                description
                  "port current performance data";
                container optics-minute15-optics {
                  description
                    "port current performance data";
                  list optics-minute15-optic {
                    key "number";
                    description
                      "port 15-minute optics performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-minute15-optic
                }  // container optics-minute15-optics

                container optics-minute15fecs {
                  description
                    "port current performance data";
                  list optics-minute15fec {
                    key "number";
                    description
                      "port 15-minute fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-minute15fec
                }  // container optics-minute15fecs
              }  // container optics-minute15

              container optics-second30 {
                description
                  "port current performance data";
                container optics-second30fecs {
                  description
                    "port current performance data";
                  list optics-second30fec {
                    key "number";
                    description
                      "port 30-second fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-second30fec
                }  // container optics-second30fecs

                container optics-second30-optics {
                  description
                    "port current performance data";
                  list optics-second30-optic {
                    key "number";
                    description
                      "port 30-second optics performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-second30-optic
                }  // container optics-second30-optics
              }  // container optics-second30
            }  // container optics-current

            container optics-prev {
              description
                "port current performance data";
              container optics-prev-flex-interval {
                description
                  "port prev performance data";
                container optics-prev-flex-interval-fecs {
                  description
                    "port prev performance data";
                  list optics-prev-flex-interval-fec {
                    key "number";
                    description
                      "port variable-second fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-prev-flex-interval-fec
                }  // container optics-prev-flex-interval-fecs

                container optics-prev-flex-interval-optics {
                  description
                    "port prev performance data";
                  list optics-prev-flex-interval-optic {
                    key "number";
                    description
                      "port variable-second optics performance
                     data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list optics-prev-flex-interval-optic
                }  // container optics-prev-flex-interval-optics
              }  // container optics-prev-flex-interval
            }  // container optics-prev

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list optics-port
        }  // container optics-ports
      }  // container optics

      container sts {
        description
          "STS controller performance data";
        container sts-ports {
          description
            "Port performance data";
          list sts-port {
            key "name";
            description
              "Port performance data";
            container sts-current {
              description
                "port current performance data";
              container sts-minute15 {
                description
                  "port current performance data";
                container sts-minute15-paths {
                  description
                    "port current performance data";
                  list sts-minute15-path {
                    key "number";
                    description
                      "port 15-minute Path performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container path {
                      description "PATH";
                      container path-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-e-ss

                      container path-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-se-ss

                      container path-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container path-c-vs

                      container path-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // 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";
                      }
                    }  // container path

                    container fe-path {
                      description
                        "Far End PATH";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list sts-minute15-path
                }  // container sts-minute15-paths
              }  // container sts-minute15

              container sts-hour24 {
                description
                  "port current performance data";
                container sts-hour24-paths {
                  description
                    "port current performance data";
                  list sts-hour24-path {
                    key "number";
                    description
                      "port 24 hour Path performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container path {
                      description "PATH";
                      container path-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container path-e-ss

                      container path-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container path-se-ss

                      container path-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container path-c-vs

                      container path-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // 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";
                      }
                    }  // container path

                    container fe-path {
                      description
                        "Far End PATH";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list sts-hour24-path
                }  // container sts-hour24-paths
              }  // container sts-hour24
            }  // container sts-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list sts-port
        }  // container sts-ports
      }  // container sts

      container dwdm {
        description
          "DWDM controller performance data";
        container dwdm-ports {
          description
            "Port performance data";
          list dwdm-port {
            key "name";
            description
              "Port performance data";
            container dwdm-current {
              description
                "port current performance data";
              container dwdm-minute15 {
                description
                  "port current performance data";
                container dwdm-minute15fecs {
                  description
                    "port current performance data";
                  list dwdm-minute15fec {
                    key "number";
                    description
                      "port 15-minute fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list dwdm-minute15fec
                }  // container dwdm-minute15fecs

                container dwdm-minute15-optics {
                  description
                    "port current performance data";
                  list dwdm-minute15-optic {
                    key "number";
                    description
                      "port 15-minute optics performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list dwdm-minute15-optic
                }  // container dwdm-minute15-optics

                container dwdm-minute15otns {
                  description
                    "port current performance data";
                  list dwdm-minute15otn {
                    key "number";
                    description
                      "port 15-minute otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list dwdm-minute15otn
                }  // container dwdm-minute15otns
              }  // container dwdm-minute15

              container dwdm-hour24 {
                description
                  "port current performance data";
                container dwdm-hour24-optics {
                  description
                    "port 24 hour performance data";
                  list dwdm-hour24-optic {
                    key "number";
                    description
                      "port 24 hour optics performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container lbc-pc {
                      description
                        "LBC in percentage";
                      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";
                      }
                    }  // container lbc-pc

                    container opt {
                      description "OPT";
                      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";
                      }
                    }  // container opt

                    container opr {
                      description "OPR";
                      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";
                      }
                    }  // container opr

                    container cd {
                      description
                        "Chromatic Dispersion";
                      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";
                      }
                    }  // container cd

                    container dgd {
                      description
                        "Differential group Delay";
                      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";
                      }
                    }  // container dgd

                    container pmd {
                      description
                        "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                      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";
                      }
                    }  // container pmd

                    container sopmd {
                      description
                        "Second order Polarization Mode Dispersion";
                      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";
                      }
                    }  // container sopmd

                    container osnr {
                      description
                        "Optical Signal to Noise Ratio";
                      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";
                      }
                    }  // container osnr

                    container center-wavelength {
                      description
                        "Center Wavelength/Frequency";
                      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";
                      }
                    }  // container center-wavelength

                    container pdl {
                      description
                        "Polarization Dependent Loss";
                      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";
                      }
                    }  // container pdl

                    container pcr {
                      description
                        "Polarization Change Rate";
                      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";
                      }
                    }  // container pcr

                    container pn {
                      description
                        "Phase Noise";
                      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";
                      }
                    }  // container pn

                    container rx-sig-pow {
                      description
                        "Rx signal power";
                      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";
                      }
                    }  // container rx-sig-pow

                    container low-sig-freq-off {
                      description
                        "low freq sig off";
                      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";
                      }
                    }  // container low-sig-freq-off

                    container ampli-gain {
                      description
                        "Ampli Gain";
                      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";
                      }
                    }  // container ampli-gain

                    container ampli-gain-tilt {
                      description
                        "Ampli Gain Tilt";
                      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";
                      }
                    }  // container ampli-gain-tilt

                    container snr {
                      description "SNR";
                      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";
                      }
                    }  // container snr

                    container snrax {
                      description "SNR AX";
                      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";
                      }
                    }  // container snrax

                    container snrbx {
                      description "SNR BX";
                      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";
                      }
                    }  // container snrbx

                    container snray {
                      description "SNR AY";
                      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";
                      }
                    }  // container snray

                    container snrby {
                      description "SNR BY";
                      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";
                      }
                    }  // container snrby

                    container sops1 {
                      description "SOP S1";
                      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";
                      }
                    }  // container sops1

                    container sops2 {
                      description "SOP S2";
                      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";
                      }
                    }  // container sops2

                    container sops3 {
                      description "SOP S3";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list dwdm-hour24-optic
                }  // container dwdm-hour24-optics

                container dwdm-hour24fecs {
                  description
                    "port current performance data";
                  list dwdm-hour24fec {
                    key "number";
                    description
                      "port 24 hour fec performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list dwdm-hour24fec
                }  // container dwdm-hour24fecs

                container dwdm-hour24otns {
                  description
                    "port 24 hour performance data";
                  list dwdm-hour24otn {
                    key "number";
                    description
                      "port 24 hour otn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container lbc {
                      description "LBC";
                      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";
                      }
                    }  // container lbc

                    container es-ne {
                      description "ES SM NE";
                      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";
                      }
                    }  // container es-ne

                    container esr-ne {
                      description
                        "ESR PM NE";
                      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";
                      }
                    }  // container esr-ne

                    container ses-ne {
                      description
                        "SES SM NE";
                      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";
                      }
                    }  // container ses-ne

                    container sesr-ne {
                      description
                        "SESR SM NE";
                      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";
                      }
                    }  // container sesr-ne

                    container uas-ne {
                      description
                        "UAS SM NE";
                      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";
                      }
                    }  // container uas-ne

                    container bbe-ne {
                      description
                        "BBE SM NE";
                      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";
                      }
                    }  // container bbe-ne

                    container bber-ne {
                      description
                        "BBER SM NE";
                      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";
                      }
                    }  // container bber-ne

                    container fc-ne {
                      description "FC SM NE";
                      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";
                      }
                    }  // container fc-ne

                    container es-fe {
                      description "ES SM FE";
                      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";
                      }
                    }  // container es-fe

                    container esr-fe {
                      description
                        "ESR PM FE";
                      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";
                      }
                    }  // container esr-fe

                    container ses-fe {
                      description
                        "SES SM FE";
                      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";
                      }
                    }  // container ses-fe

                    container sesr-fe {
                      description
                        "SESR SM FE";
                      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";
                      }
                    }  // container sesr-fe

                    container uas-fe {
                      description
                        "UAS SM FE";
                      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";
                      }
                    }  // container uas-fe

                    container bbe-fe {
                      description
                        "BBE SM FE";
                      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";
                      }
                    }  // container bbe-fe

                    container bber-fe {
                      description
                        "BBER SM FE";
                      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";
                      }
                    }  // container bber-fe

                    container fc-fe {
                      description "FC SM FE";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list dwdm-hour24otn
                }  // container dwdm-hour24otns
              }  // container dwdm-hour24
            }  // container dwdm-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list dwdm-port
        }  // container dwdm-ports
      }  // container dwdm

      container oc {
        description
          "OC controller performance data";
        container oc-ports {
          description
            "Port performance data";
          list oc-port {
            key "name";
            description
              "Port performance data";
            container oc-current {
              description
                "port current performance data";
              container oc-hour24 {
                description
                  "port current performance data";
                container oc-hour24ocns {
                  description
                    "port current performance data";
                  list oc-hour24ocn {
                    key "number";
                    description
                      "port 24 hour ocn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container section {
                      description "SECTION";
                      container section-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container section-e-ss

                      container section-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container section-se-ss

                      container section-sef-ss {
                        description
                          "The number of Severely Errored Framing Seconds";
                        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";
                        }
                      }  // container section-sef-ss

                      container section-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container section-c-vs

                      leaf section-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container section

                    container line {
                      description "LINE";
                      container line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container line-e-ss

                      container line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container line-se-ss

                      container line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container line-c-vs

                      container line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container line-ua-ss

                      container line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container line-fc-ls

                      leaf line-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container line

                    container fe-line {
                      description
                        "FarEnd LINE";
                      container far-end-line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-e-ss

                      container far-end-line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-se-ss

                      container far-end-line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container far-end-line-c-vs

                      container far-end-line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container far-end-line-ua-ss

                      container far-end-line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container far-end-line-fc-ls
                    }  // 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";
                    }
                  }  // list oc-hour24ocn
                }  // container oc-hour24ocns
              }  // container oc-hour24

              container oc-minute15 {
                description
                  "port current performance data";
                container oc-minute15ocns {
                  description
                    "port current performance data";
                  list oc-minute15ocn {
                    key "number";
                    description
                      "port 15-minute ocn performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container section {
                      description "SECTION";
                      container section-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container section-e-ss

                      container section-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container section-se-ss

                      container section-sef-ss {
                        description
                          "The number of Severely Errored Framing Seconds";
                        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";
                        }
                      }  // container section-sef-ss

                      container section-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container section-c-vs

                      leaf section-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container section

                    container line {
                      description "LINE";
                      container line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container line-e-ss

                      container line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container line-se-ss

                      container line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container line-c-vs

                      container line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container line-ua-ss

                      container line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container line-fc-ls

                      leaf line-status {
                        type int32;
                        description
                          " status of the interface";
                      }
                    }  // container line

                    container fe-line {
                      description
                        "FarEnd LINE";
                      container far-end-line-e-ss {
                        description
                          "The number of Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-e-ss

                      container far-end-line-se-ss {
                        description
                          "The number of Severely Errored Seconds";
                        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";
                        }
                      }  // container far-end-line-se-ss

                      container far-end-line-c-vs {
                        description
                          "The number of Coding Violations";
                        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";
                        }
                      }  // container far-end-line-c-vs

                      container far-end-line-ua-ss {
                        description
                          "The number of Unavailable Seconds";
                        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";
                        }
                      }  // container far-end-line-ua-ss

                      container far-end-line-fc-ls {
                        description
                          "The number of Failure counts Seconds";
                        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";
                        }
                      }  // container far-end-line-fc-ls
                    }  // 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";
                    }
                  }  // list oc-minute15ocn
                }  // container oc-minute15ocns
              }  // container oc-minute15
            }  // container oc-current

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list oc-port
        }  // container oc-ports
      }  // container oc

      container ethernet {
        description
          "EHERNET controller performance data";
        container ethernet-ports {
          description
            "Port performance data";
          list ethernet-port {
            key "name";
            description
              "Port performance data";
            container ethernet-current {
              description
                "port current performance data";
              container ethernet-flex-interval {
                description
                  "port current performance data";
                container ethernet-flex-interval-pcses {
                  description
                    "ETHERNET port interval performance data";
                  list ethernet-flex-interval-pcs {
                    key "slot-number";
                    description
                      "Ethernet port flex second pcs  performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container bip {
                      description "Bip ";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bip

                    container frm-err {
                      description "Frm Err";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container frm-err

                    container bad-sh {
                      description "Bad Sh";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bad-sh

                    container es-ne {
                      description "Es Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-ne

                    container ses-ne {
                      description "Ses Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-ne

                    container uas-ne {
                      description "Uas Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container uas-ne

                    container es-fe {
                      description "Es Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-fe

                    container ses-fe {
                      description "Ese Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-fe

                    container uas-fe {
                      description "Uas Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // 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";
                    }
                  }  // list ethernet-flex-interval-pcs
                }  // container ethernet-flex-interval-pcses

                container ethernet-flex-interval-fecs {
                  description
                    "port current performance data";
                  list ethernet-flex-interval-fec {
                    key "number";
                    description
                      "port flex sec ethernet performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ethernet-flex-interval-fec
                }  // container ethernet-flex-interval-fecs

                container ethernet-flex-interval-ether-s {
                  description
                    "port current performance data";
                  list ethernet-flex-interval-ether {
                    key "number";
                    description
                      "port flex sec ethernet performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ethernet-flex-interval-ether
                }  // container ethernet-flex-interval-ether-s
              }  // container ethernet-flex-interval

              container ethernet-second30 {
                description
                  "port current performance data";
                container second30-fecs {
                  description
                    "ETHERNET port interval performance data";
                  list second30-fec {
                    key "slot-number";
                    description
                      "ETHERNET port 30 second fec performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list second30-fec
                }  // container second30-fecs

                container second30pcses {
                  description
                    "ETHERNET port interval performance data";
                  list second30pcs {
                    key "slot-number";
                    description
                      "Ethernet port 30 second pcs  performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container bip {
                      description "Bip ";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bip

                    container frm-err {
                      description "Frm Err";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container frm-err

                    container bad-sh {
                      description "Bad Sh";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bad-sh

                    container es-ne {
                      description "Es Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-ne

                    container ses-ne {
                      description "Ses Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-ne

                    container uas-ne {
                      description "Uas Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container uas-ne

                    container es-fe {
                      description "Es Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-fe

                    container ses-fe {
                      description "Ese Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-fe

                    container uas-fe {
                      description "Uas Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // 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";
                    }
                  }  // list second30pcs
                }  // container second30pcses

                container second30-ethers {
                  description
                    "ETHERNET port interval performance data";
                  list second30-ether {
                    key "slot-number";
                    description
                      "ETHERNET port 30 second ether performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list second30-ether
                }  // container second30-ethers
              }  // container ethernet-second30

              container ethernet-hour24 {
                description
                  "port current performance data";
                container ethernet-hour24-ether-s {
                  description
                    "port current performance data";
                  list ethernet-hour24-ether {
                    key "number";
                    description
                      "port 24 hour ethernet performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ethernet-hour24-ether
                }  // container ethernet-hour24-ether-s

                container hour24pcses {
                  description
                    "port current performance data";
                  list hour24pcs {
                    key "number";
                    description
                      "Ethernet port 24 hour pcs performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container bip {
                      description "Bip ";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bip

                    container frm-err {
                      description "Frm Err";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container frm-err

                    container bad-sh {
                      description "Bad Sh";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bad-sh

                    container es-ne {
                      description "Es Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-ne

                    container ses-ne {
                      description "Ses Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-ne

                    container uas-ne {
                      description "Uas Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container uas-ne

                    container es-fe {
                      description "Es Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-fe

                    container ses-fe {
                      description "Ese Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-fe

                    container uas-fe {
                      description "Uas Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // 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";
                    }
                  }  // list hour24pcs
                }  // container hour24pcses

                container ethernet-hour24fecs {
                  description
                    "port current performance data";
                  list ethernet-hour24fec {
                    key "number";
                    description
                      "port 24 hour ethernet performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ethernet-hour24fec
                }  // container ethernet-hour24fecs
              }  // container ethernet-hour24

              container minute15 {
                description
                  "port current performance data";
                container minute15-fecs {
                  description
                    "ETHERNET port interval performance data";
                  list minute15-fec {
                    key "slot-number";
                    description
                      "ETHERNET port 15-minute fec performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list minute15-fec
                }  // container minute15-fecs

                container minute15pcses {
                  description
                    "ETHERNET port interval performance data";
                  list minute15pcs {
                    key "slot-number";
                    description
                      "ETHERNET port 15-minute pcs performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container bip {
                      description "Bip ";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bip

                    container frm-err {
                      description "Frm Err";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container frm-err

                    container bad-sh {
                      description "Bad Sh";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bad-sh

                    container es-ne {
                      description "Es Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-ne

                    container ses-ne {
                      description "Ses Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-ne

                    container uas-ne {
                      description "Uas Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container uas-ne

                    container es-fe {
                      description "Es Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-fe

                    container ses-fe {
                      description "Ese Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-fe

                    container uas-fe {
                      description "Uas Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // 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";
                    }
                  }  // list minute15pcs
                }  // container minute15pcses

                container minute15-ethers {
                  description
                    "ETHERNET port interval performance data";
                  list minute15-ether {
                    key "slot-number";
                    description
                      "ETHERNET port 15-minute ether performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list minute15-ether
                }  // container minute15-ethers
              }  // container minute15
            }  // container ethernet-current

            container ethernet-prev {
              description
                "port prev performance data";
              container ethernet-prev-flex-interval {
                description
                  "port prev performance data";
                container ethernet-prev-flex-interval-ether-s {
                  description
                    "port prev performance data";
                  list ethernet-prev-flex-interval-ether {
                    key "number";
                    description
                      "port flex sec ethernet performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container rx-pkt {
                      description "RX PKT";
                      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";
                      }
                    }  // container rx-pkt

                    container stat-pkt {
                      description "STAT PKT";
                      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";
                      }
                    }  // container stat-pkt

                    container octet-stat {
                      description
                        "OCTET STAT";
                      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";
                      }
                    }  // container octet-stat

                    container oversize-pkt-stat {
                      description
                        "OVERSIZE PKT";
                      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";
                      }
                    }  // container oversize-pkt-stat

                    container fcs-errors-stat {
                      description "FCS ERR";
                      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";
                      }
                    }  // container fcs-errors-stat

                    container long-frames-stat {
                      description
                        "LONG FRAMES";
                      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";
                      }
                    }  // container long-frames-stat

                    container jabber-stat {
                      description
                        "JABBER STATS";
                      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";
                      }
                    }  // container jabber-stat

                    container ether64-octets {
                      description
                        "SIXTY FOUR OCTET";
                      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";
                      }
                    }  // container ether64-octets

                    container ether65127-octet {
                      description "OCTET";
                      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";
                      }
                    }  // container ether65127-octet

                    container ether128255-octet {
                      description
                        "TFF OCTET";
                      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";
                      }
                    }  // container ether128255-octet

                    container ether256511-octet {
                      description
                        "FOO OCTET";
                      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";
                      }
                    }  // container ether256511-octet

                    container ether5121023-octet {
                      description
                        "OZTT OCTET";
                      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";
                      }
                    }  // container ether5121023-octet

                    container ether10241518-octet {
                      description
                        "OFO OCTET";
                      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";
                      }
                    }  // container ether10241518-octet

                    container in-ucast-pkt {
                      description "IN UCAST";
                      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";
                      }
                    }  // container in-ucast-pkt

                    container in-mcast-pkt {
                      description "IN MCAST";
                      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";
                      }
                    }  // container in-mcast-pkt

                    container in-bcast-pkt {
                      description "IN BCAST";
                      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";
                      }
                    }  // container in-bcast-pkt

                    container out-ucast-pkt {
                      description
                        "OUT UCAST";
                      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";
                      }
                    }  // container out-ucast-pkt

                    container out-bcast-pkt {
                      description
                        "OUT BCAST";
                      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";
                      }
                    }  // container out-bcast-pkt

                    container out-mcast-pkt {
                      description
                        "OUT MCAST";
                      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";
                      }
                    }  // container out-mcast-pkt

                    container tx-pkt {
                      description "TX PKT";
                      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";
                      }
                    }  // container tx-pkt

                    container if-in-errors {
                      description
                        "IFIN ERRORS";
                      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";
                      }
                    }  // container if-in-errors

                    container if-in-octets {
                      description
                        "IFIN OCTETS";
                      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";
                      }
                    }  // container if-in-octets

                    container ether-stat-multicast-pkt {
                      description
                        "ETHER STAT MULTICAST PKT";
                      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";
                      }
                    }  // container ether-stat-multicast-pkt

                    container ether-stat-broadcast-pkt {
                      description
                        "ETHER STAT BROADCAST PKT";
                      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";
                      }
                    }  // container ether-stat-broadcast-pkt

                    container ether-stat-undersized-pkt {
                      description
                        "ETHER STAT UNDERSIZED PKT";
                      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";
                      }
                    }  // container ether-stat-undersized-pkt

                    container out-octets {
                      description
                        "OUT OCTET";
                      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";
                      }
                    }  // container out-octets

                    container in-pause-frame {
                      description
                        "INPUT PAUSE FRAME";
                      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";
                      }
                    }  // container in-pause-frame

                    container in-good-bytes {
                      description
                        "INPUT GOOD BYTES";
                      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";
                      }
                    }  // container in-good-bytes

                    container in8021q-frames {
                      description
                        "INPUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container in8021q-frames

                    container in-pkts1519-max-octets {
                      description
                        "INPUT PKTS 1519MAX OCTETS";
                      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";
                      }
                    }  // container in-pkts1519-max-octets

                    container in-good-pkts {
                      description
                        "INPUT GOOD PKTS";
                      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";
                      }
                    }  // container in-good-pkts

                    container in-drop-overrun {
                      description
                        "INPUT DROP OVERRUN";
                      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";
                      }
                    }  // container in-drop-overrun

                    container in-drop-abort {
                      description
                        "INPUT DROP ABORT";
                      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";
                      }
                    }  // container in-drop-abort

                    container in-drop-invalid-vlan {
                      description
                        "INPUT DROP INVALID VLAN";
                      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";
                      }
                    }  // container in-drop-invalid-vlan

                    container in-drop-invalid-dmac {
                      description
                        "INPUT DROP INVALID DMAC";
                      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";
                      }
                    }  // container in-drop-invalid-dmac

                    container in-drop-invalid-encap {
                      description
                        "INPUT DROP INVALID ENCAP";
                      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";
                      }
                    }  // container in-drop-invalid-encap

                    container in-drop-other {
                      description
                        "INPUT DROP OTHER";
                      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";
                      }
                    }  // container in-drop-other

                    container in-mib-giant {
                      description
                        "INPUT MIB GIANT";
                      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";
                      }
                    }  // container in-mib-giant

                    container in-mib-jabber {
                      description
                        "INPUT MIB JABBER";
                      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";
                      }
                    }  // container in-mib-jabber

                    container in-mibcrc {
                      description
                        "IN MIB CRC";
                      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";
                      }
                    }  // container in-mibcrc

                    container in-error-collisions {
                      description
                        "IN ERROR COLLISIONS";
                      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";
                      }
                    }  // container in-error-collisions

                    container in-error-symbol {
                      description
                        "IN ERROR SYMBOL";
                      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";
                      }
                    }  // container in-error-symbol

                    container out-good-bytes {
                      description
                        "OUT GOOD BYTES";
                      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";
                      }
                    }  // container out-good-bytes

                    container out8021q-frames {
                      description
                        "OUT 802 1Q FRAMES";
                      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";
                      }
                    }  // container out8021q-frames

                    container out-pause-frames {
                      description
                        "OUT PAUSE FRAMES";
                      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";
                      }
                    }  // container out-pause-frames

                    container out-pkts1519-max-octets {
                      description
                        "OUT PKTS 1519 MAX OCTETS";
                      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";
                      }
                    }  // container out-pkts1519-max-octets

                    container out-good-pkts {
                      description
                        "OUT GOOD PKTS";
                      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";
                      }
                    }  // container out-good-pkts

                    container out-drop-underrun {
                      description
                        "OUT DROP UNDERRUN";
                      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";
                      }
                    }  // container out-drop-underrun

                    container out-drop-abort {
                      description
                        "OUT DROP ABORT";
                      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";
                      }
                    }  // container out-drop-abort

                    container out-drop-other {
                      description
                        "OUT DROP OTHER";
                      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";
                      }
                    }  // container out-drop-other

                    container out-error-other {
                      description
                        "OUT ERROR OTHER";
                      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";
                      }
                    }  // container out-error-other

                    container in-error-giant {
                      description
                        "IN ERROR GIANT";
                      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";
                      }
                    }  // container in-error-giant

                    container in-error-runt {
                      description
                        "IN ERROR RUNT";
                      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";
                      }
                    }  // container in-error-runt

                    container in-error-jabbers {
                      description
                        "IN ERROR JABBERS";
                      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";
                      }
                    }  // container in-error-jabbers

                    container in-error-fragments {
                      description
                        "IN ERROR FRAGMENTS";
                      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";
                      }
                    }  // container in-error-fragments

                    container in-error-other {
                      description
                        "IN ERROR OTHER";
                      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";
                      }
                    }  // container in-error-other

                    container in-pkt64-octet {
                      description
                        "IN PKT 64 OCTET";
                      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";
                      }
                    }  // container in-pkt64-octet

                    container in-pkts65-to127-octets {
                      description
                        "IN PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container in-pkts65-to127-octets

                    container in-pkts128-to255-octets {
                      description
                        "IN PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container in-pkts128-to255-octets

                    container in-pkts256-to511-octets {
                      description
                        "IN PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container in-pkts256-to511-octets

                    container in-pkts512-to1023-octets {
                      description
                        "IN PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container in-pkts512-to1023-octets

                    container in-pkts1024-to1518-octets {
                      description
                        "IN PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container in-pkts1024-to1518-octets

                    container outpkt64octet {
                      description
                        "OUT PKT 64 OCTET";
                      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";
                      }
                    }  // container outpkt64octet

                    container out-pkts65127-octets {
                      description
                        "OUT PKTS 65 127OCTETS";
                      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";
                      }
                    }  // container out-pkts65127-octets

                    container out-pkts128255-octets {
                      description
                        "OUT PKTS 128 255 OCTETS";
                      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";
                      }
                    }  // container out-pkts128255-octets

                    container out-pkts256511-octets {
                      description
                        "OUT PKTS 256 511 OCTETS";
                      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";
                      }
                    }  // container out-pkts256511-octets

                    container out-pkts5121023-octets {
                      description
                        "OUT PKTS 512 1023 OCTETS";
                      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";
                      }
                    }  // container out-pkts5121023-octets

                    container out-pkts10241518-octets {
                      description
                        "OUT PKTS 1024 1518 OCTETS";
                      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";
                      }
                    }  // container out-pkts10241518-octets

                    container rx-util {
                      description
                        "Rx Utilization in Percent";
                      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";
                      }
                    }  // container rx-util

                    container tx-util {
                      description
                        "Tx Utilization in Percent";
                      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";
                      }
                    }  // container tx-util

                    container tx-undersized-pkt {
                      description
                        "TX Undersized Pkt";
                      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";
                      }
                    }  // container tx-undersized-pkt

                    container tx-oversized-pkt {
                      description
                        "TX Oversized Pkt";
                      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";
                      }
                    }  // container tx-oversized-pkt

                    container tx-fragments {
                      description
                        "TX Fragments";
                      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";
                      }
                    }  // container tx-fragments

                    container tx-jabber {
                      description
                        "TX Jabber";
                      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";
                      }
                    }  // container tx-jabber

                    container tx-bad-fcs {
                      description
                        "TX Bad Fcs";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ethernet-prev-flex-interval-ether
                }  // container ethernet-prev-flex-interval-ether-s

                container ethernet-prev-flex-interval-pcses {
                  description
                    "ETHERNET port interval performance data";
                  list ethernet-prev-flex-interval-pcs {
                    key "slot-number";
                    description
                      "Ethernet port flex second pcs performance
                     data";
                    leaf slot-number {
                      type uint32;
                      description
                        "interval slot number";
                    }

                    container bip {
                      description "Bip ";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bip

                    container frm-err {
                      description "Frm Err";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container frm-err

                    container bad-sh {
                      description "Bad Sh";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container bad-sh

                    container es-ne {
                      description "Es Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-ne

                    container ses-ne {
                      description "Ses Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-ne

                    container uas-ne {
                      description "Uas Ne";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container uas-ne

                    container es-fe {
                      description "Es Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container es-fe

                    container ses-fe {
                      description "Ese Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // container ses-fe

                    container uas-fe {
                      description "Uas Fe";
                      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";
                        leaf name {
                          type string {
                            length "0..19";
                          }
                          description
                            "pcs param name";
                        }

                        leaf data {
                          type uint64;
                          description
                            "the threshold users set";
                        }
                      }  // list count
                    }  // 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";
                    }
                  }  // list ethernet-prev-flex-interval-pcs
                }  // container ethernet-prev-flex-interval-pcses

                container ethernet-prev-flex-interval-fecs {
                  description
                    "port prev performance data";
                  list ethernet-prev-flex-interval-fec {
                    key "number";
                    description
                      "port flex sec ethernet performance data";
                    leaf number {
                      type uint32;
                      description
                        "channel number";
                    }

                    container ec-bits {
                      description "EC BITS";
                      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";
                      }
                    }  // container ec-bits

                    container uc-words {
                      description "UC WORDS";
                      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";
                      }
                    }  // container uc-words

                    container pre-fec-ber {
                      description
                        "Pre FEC BER";
                      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";
                      }
                    }  // container pre-fec-ber

                    container post-fec-ber {
                      description
                        "Post FEC BER";
                      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";
                      }
                    }  // container post-fec-ber

                    container q {
                      description "Q";
                      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";
                      }
                    }  // container q

                    container qmargin {
                      description "Q Margin";
                      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";
                      }
                    }  // container qmargin

                    container qmargin-inst {
                      description
                        "Q Margin Instantaneous";
                      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";
                      }
                    }  // container qmargin-inst

                    container ec-words {
                      description "EC Words";
                      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";
                      }
                    }  // 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";
                    }
                  }  // list ethernet-prev-flex-interval-fec
                }  // container ethernet-prev-flex-interval-fecs
              }  // container ethernet-prev-flex-interval
            }  // container ethernet-prev

            leaf name {
              type xr:Interface-name;
              description "Port name";
            }
          }  // list ethernet-port
        }  // container ethernet-ports
      }  // container ethernet
    }  // container performance-management

    container performance-management-history {
      config false;
      description "performace data";
      container global {
        description
          "global History performace data";
        container periodic {
          description
            "History performace data";
          container sonet-history {
            description
              "SONET controller History performance data";
            container sonet-port-histories {
              description
                "Port performance data";
              list sonet-port-history {
                key "name";
                description
                  "Port performance data";
                container sonet-minute15-history {
                  description
                    "port current performance data";
                  container sonet-minute15ocn-histories {
                    description
                      "port current performance data";
                    list sonet-minute15ocn-history {
                      key "number";
                      description
                        "port 15-minute ocn performance data";
                      container sonet-minute15ocn-time-line-instances {
                        description
                          "port current performance data";
                        list sonet-minute15ocn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container section {
                            description
                              "SECTION";
                            container section-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container section-e-ss

                            container section-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container section-se-ss

                            container section-sef-ss {
                              description
                                "The number of Severely Errored Framing Seconds";
                              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";
                              }
                            }  // container section-sef-ss

                            container section-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container section-c-vs

                            leaf section-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container section

                          container line {
                            description
                              "LINE";
                            container line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container line-e-ss

                            container line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container line-se-ss

                            container line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container line-c-vs

                            container line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container line-ua-ss

                            container line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container line-fc-ls

                            leaf line-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container line

                          container fe-line {
                            description
                              "FarEnd LINE";
                            container far-end-line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-e-ss

                            container far-end-line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-se-ss

                            container far-end-line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container far-end-line-c-vs

                            container far-end-line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container far-end-line-ua-ss

                            container far-end-line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container far-end-line-fc-ls
                          }  // 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";
                          }
                        }  // list sonet-minute15ocn-time-line-instance
                      }  // container sonet-minute15ocn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list sonet-minute15ocn-history
                  }  // container sonet-minute15ocn-histories

                  container sonet-minute15-path-histories {
                    description
                      "port current performance data";
                    list sonet-minute15-path-history {
                      key "number";
                      description
                        "port 15-minute Path performance data";
                      container sonet-minute15-path-time-line-instances {
                        description
                          "port current performance data";
                        list sonet-minute15-path-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container path {
                            description
                              "PATH";
                            container path-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-e-ss

                            container path-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-se-ss

                            container path-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container path-c-vs

                            container path-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // 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";
                            }
                          }  // container path

                          container fe-path {
                            description
                              "Far End PATH";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list sonet-minute15-path-time-line-instance
                      }  // container sonet-minute15-path-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list sonet-minute15-path-history
                  }  // container sonet-minute15-path-histories
                }  // container sonet-minute15-history

                container sonet-hour24-history {
                  description
                    "port current performance data";
                  container sonet-hour24-path-histories {
                    description
                      "port current performance data";
                    list sonet-hour24-path-history {
                      key "number";
                      description
                        "port 24 hour Path performance data";
                      container sonet-hour24-path-time-line-instances {
                        description
                          "port current performance data";
                        list sonet-hour24-path-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container path {
                            description
                              "PATH";
                            container path-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-e-ss

                            container path-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-se-ss

                            container path-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container path-c-vs

                            container path-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // 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";
                            }
                          }  // container path

                          container fe-path {
                            description
                              "Far End PATH";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list sonet-hour24-path-time-line-instance
                      }  // container sonet-hour24-path-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list sonet-hour24-path-history
                  }  // container sonet-hour24-path-histories

                  container sonet-hour24ocn-histories {
                    description
                      "port current performance data";
                    list sonet-hour24ocn-history {
                      key "number";
                      description
                        "port 24 hour ocn performance data";
                      container sonet-hour24ocn-time-line-instances {
                        description
                          "port current performance data";
                        list sonet-hour24ocn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container section {
                            description
                              "SECTION";
                            container section-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container section-e-ss

                            container section-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container section-se-ss

                            container section-sef-ss {
                              description
                                "The number of Severely Errored Framing Seconds";
                              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";
                              }
                            }  // container section-sef-ss

                            container section-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container section-c-vs

                            leaf section-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container section

                          container line {
                            description
                              "LINE";
                            container line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container line-e-ss

                            container line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container line-se-ss

                            container line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container line-c-vs

                            container line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container line-ua-ss

                            container line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container line-fc-ls

                            leaf line-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container line

                          container fe-line {
                            description
                              "FarEnd LINE";
                            container far-end-line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-e-ss

                            container far-end-line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-se-ss

                            container far-end-line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container far-end-line-c-vs

                            container far-end-line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container far-end-line-ua-ss

                            container far-end-line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container far-end-line-fc-ls
                          }  // 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";
                          }
                        }  // list sonet-hour24ocn-time-line-instance
                      }  // container sonet-hour24ocn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list sonet-hour24ocn-history
                  }  // container sonet-hour24ocn-histories
                }  // container sonet-hour24-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list sonet-port-history
            }  // container sonet-port-histories
          }  // container sonet-history

          container sts-history {
            description
              "STS controller History performance data";
            container sts-port-histories {
              description
                "Port performance data";
              list sts-port-history {
                key "name";
                description
                  "Port performance data";
                container sts-minute15-history {
                  description
                    "port current performance data";
                  container sts-minute15-path-histories {
                    description
                      "port current performance data";
                    list sts-minute15-path-history {
                      key "number";
                      description
                        "port 15-minute Path performance data";
                      container sts-minute15-path-time-line-instances {
                        description
                          "port current performance data";
                        list sts-minute15-path-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container path {
                            description
                              "PATH";
                            container path-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-e-ss

                            container path-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-se-ss

                            container path-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container path-c-vs

                            container path-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // 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";
                            }
                          }  // container path

                          container fe-path {
                            description
                              "Far End PATH";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list sts-minute15-path-time-line-instance
                      }  // container sts-minute15-path-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list sts-minute15-path-history
                  }  // container sts-minute15-path-histories
                }  // container sts-minute15-history

                container sts-hour24-history {
                  description
                    "port current performance data";
                  container sts-hour24-path-histories {
                    description
                      "port current performance data";
                    list sts-hour24-path-history {
                      key "number";
                      description
                        "port 24 hour Path performance data";
                      container sts-hour24-path-time-line-instances {
                        description
                          "port current performance data";
                        list sts-hour24-path-time-line-instance {
                          key "number";
                          description
                            "port 15-minute sts performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container path {
                            description
                              "PATH";
                            container path-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-e-ss

                            container path-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-se-ss

                            container path-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container path-c-vs

                            container path-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // 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";
                            }
                          }  // container path

                          container fe-path {
                            description
                              "Far End PATH";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list sts-hour24-path-time-line-instance
                      }  // container sts-hour24-path-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list sts-hour24-path-history
                  }  // container sts-hour24-path-histories
                }  // container sts-hour24-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list sts-port-history
            }  // container sts-port-histories
          }  // container sts-history

          container ethernet-history {
            description
              "EHERNET controller History performance data";
            container ethernet-port-histories {
              description
                "Port performance data";
              list ethernet-port-history {
                key "name";
                description
                  "Port performance data";
                container ethernet-second30-history {
                  description
                    "port current performance data";
                  container second30pcs-histories {
                    description
                      "ETHERNET port interval performance data";
                    list second30pcs-history {
                      key "slot-number";
                      description
                        "ETHERNET port 30 sec pcs performance data";
                      container second30pcs-time-line-instances {
                        description
                          "port current performance data";
                        list second30pcs-time-line-instance {
                          key "number";
                          description
                            "port 30 sec pcs performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container bip {
                            description
                              "Bip ";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container bip

                          container frm-err {
                            description
                              "Frm Err";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container frm-err

                          container bad-sh {
                            description
                              "Bad Sh";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container bad-sh

                          container es-ne {
                            description
                              "Es Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container es-ne

                          container ses-ne {
                            description
                              "Ses Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container ses-ne

                          container uas-ne {
                            description
                              "Uas Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container uas-ne

                          container es-fe {
                            description
                              "Es Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container es-fe

                          container ses-fe {
                            description
                              "Ese Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container ses-fe

                          container uas-fe {
                            description
                              "Uas Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // 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";
                          }
                        }  // list second30pcs-time-line-instance
                      }  // container second30pcs-time-line-instances

                      leaf slot-number {
                        type uint32;
                        description
                          "interval slot number";
                      }
                    }  // list second30pcs-history
                  }  // container second30pcs-histories

                  container second30-ether-histories {
                    description
                      "ETHERNET port interval performance data";
                    list second30-ether-history {
                      key "slot-number";
                      description
                        "ETHERNET port 30 sec ether performance
                       data";
                      container second30-ether-time-line-instances {
                        description
                          "port current performance data";
                        list second30-ether-time-line-instance {
                          key "number";
                          description
                            "port 30 sec otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container rx-pkt {
                            description
                              "RX PKT";
                            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";
                            }
                          }  // container rx-pkt

                          container stat-pkt {
                            description
                              "STAT PKT";
                            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";
                            }
                          }  // container stat-pkt

                          container octet-stat {
                            description
                              "OCTET STAT";
                            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";
                            }
                          }  // container octet-stat

                          container oversize-pkt-stat {
                            description
                              "OVERSIZE PKT";
                            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";
                            }
                          }  // container oversize-pkt-stat

                          container fcs-errors-stat {
                            description
                              "FCS ERR";
                            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";
                            }
                          }  // container fcs-errors-stat

                          container long-frames-stat {
                            description
                              "LONG FRAMES";
                            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";
                            }
                          }  // container long-frames-stat

                          container jabber-stat {
                            description
                              "JABBER STATS";
                            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";
                            }
                          }  // container jabber-stat

                          container ether64-octets {
                            description
                              "SIXTY FOUR OCTET";
                            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";
                            }
                          }  // container ether64-octets

                          container ether65127-octet {
                            description
                              "OCTET";
                            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";
                            }
                          }  // container ether65127-octet

                          container ether128255-octet {
                            description
                              "TFF OCTET";
                            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";
                            }
                          }  // container ether128255-octet

                          container ether256511-octet {
                            description
                              "FOO OCTET";
                            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";
                            }
                          }  // container ether256511-octet

                          container ether5121023-octet {
                            description
                              "OZTT OCTET";
                            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";
                            }
                          }  // container ether5121023-octet

                          container ether10241518-octet {
                            description
                              "OFO OCTET";
                            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";
                            }
                          }  // container ether10241518-octet

                          container in-ucast-pkt {
                            description
                              "IN UCAST";
                            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";
                            }
                          }  // container in-ucast-pkt

                          container in-mcast-pkt {
                            description
                              "IN MCAST";
                            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";
                            }
                          }  // container in-mcast-pkt

                          container in-bcast-pkt {
                            description
                              "IN BCAST";
                            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";
                            }
                          }  // container in-bcast-pkt

                          container out-ucast-pkt {
                            description
                              "OUT UCAST";
                            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";
                            }
                          }  // container out-ucast-pkt

                          container out-bcast-pkt {
                            description
                              "OUT BCAST";
                            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";
                            }
                          }  // container out-bcast-pkt

                          container out-mcast-pkt {
                            description
                              "OUT MCAST";
                            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";
                            }
                          }  // container out-mcast-pkt

                          container tx-pkt {
                            description
                              "TX PKT";
                            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";
                            }
                          }  // container tx-pkt

                          container if-in-errors {
                            description
                              "IFIN ERRORS";
                            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";
                            }
                          }  // container if-in-errors

                          container if-in-octets {
                            description
                              "IFIN OCTETS";
                            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";
                            }
                          }  // container if-in-octets

                          container ether-stat-multicast-pkt {
                            description
                              "ETHER STAT MULTICAST PKT";
                            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";
                            }
                          }  // container ether-stat-multicast-pkt

                          container ether-stat-broadcast-pkt {
                            description
                              "ETHER STAT BROADCAST PKT";
                            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";
                            }
                          }  // container ether-stat-broadcast-pkt

                          container ether-stat-undersized-pkt {
                            description
                              "ETHER STAT UNDERSIZED PKT";
                            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";
                            }
                          }  // container ether-stat-undersized-pkt

                          container out-octets {
                            description
                              "OUT OCTET";
                            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";
                            }
                          }  // container out-octets

                          container in-pause-frame {
                            description
                              "INPUT PAUSE FRAME";
                            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";
                            }
                          }  // container in-pause-frame

                          container in-good-bytes {
                            description
                              "INPUT GOOD BYTES";
                            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";
                            }
                          }  // container in-good-bytes

                          container in8021q-frames {
                            description
                              "INPUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container in8021q-frames

                          container in-pkts1519-max-octets {
                            description
                              "INPUT PKTS 1519MAX OCTETS";
                            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";
                            }
                          }  // container in-pkts1519-max-octets

                          container in-good-pkts {
                            description
                              "INPUT GOOD PKTS";
                            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";
                            }
                          }  // container in-good-pkts

                          container in-drop-overrun {
                            description
                              "INPUT DROP OVERRUN";
                            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";
                            }
                          }  // container in-drop-overrun

                          container in-drop-abort {
                            description
                              "INPUT DROP ABORT";
                            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";
                            }
                          }  // container in-drop-abort

                          container in-drop-invalid-vlan {
                            description
                              "INPUT DROP INVALID VLAN";
                            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";
                            }
                          }  // container in-drop-invalid-vlan

                          container in-drop-invalid-dmac {
                            description
                              "INPUT DROP INVALID DMAC";
                            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";
                            }
                          }  // container in-drop-invalid-dmac

                          container in-drop-invalid-encap {
                            description
                              "INPUT DROP INVALID ENCAP";
                            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";
                            }
                          }  // container in-drop-invalid-encap

                          container in-drop-other {
                            description
                              "INPUT DROP OTHER";
                            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";
                            }
                          }  // container in-drop-other

                          container in-mib-giant {
                            description
                              "INPUT MIB GIANT";
                            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";
                            }
                          }  // container in-mib-giant

                          container in-mib-jabber {
                            description
                              "INPUT MIB JABBER";
                            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";
                            }
                          }  // container in-mib-jabber

                          container in-mibcrc {
                            description
                              "IN MIB CRC";
                            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";
                            }
                          }  // container in-mibcrc

                          container in-error-collisions {
                            description
                              "IN ERROR COLLISIONS";
                            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";
                            }
                          }  // container in-error-collisions

                          container in-error-symbol {
                            description
                              "IN ERROR SYMBOL";
                            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";
                            }
                          }  // container in-error-symbol

                          container out-good-bytes {
                            description
                              "OUT GOOD BYTES";
                            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";
                            }
                          }  // container out-good-bytes

                          container out8021q-frames {
                            description
                              "OUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container out8021q-frames

                          container out-pause-frames {
                            description
                              "OUT PAUSE FRAMES";
                            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";
                            }
                          }  // container out-pause-frames

                          container out-pkts1519-max-octets {
                            description
                              "OUT PKTS 1519 MAX OCTETS";
                            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";
                            }
                          }  // container out-pkts1519-max-octets

                          container out-good-pkts {
                            description
                              "OUT GOOD PKTS";
                            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";
                            }
                          }  // container out-good-pkts

                          container out-drop-underrun {
                            description
                              "OUT DROP UNDERRUN";
                            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";
                            }
                          }  // container out-drop-underrun

                          container out-drop-abort {
                            description
                              "OUT DROP ABORT";
                            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";
                            }
                          }  // container out-drop-abort

                          container out-drop-other {
                            description
                              "OUT DROP OTHER";
                            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";
                            }
                          }  // container out-drop-other

                          container out-error-other {
                            description
                              "OUT ERROR OTHER";
                            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";
                            }
                          }  // container out-error-other

                          container in-error-giant {
                            description
                              "IN ERROR GIANT";
                            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";
                            }
                          }  // container in-error-giant

                          container in-error-runt {
                            description
                              "IN ERROR RUNT";
                            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";
                            }
                          }  // container in-error-runt

                          container in-error-jabbers {
                            description
                              "IN ERROR JABBERS";
                            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";
                            }
                          }  // container in-error-jabbers

                          container in-error-fragments {
                            description
                              "IN ERROR FRAGMENTS";
                            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";
                            }
                          }  // container in-error-fragments

                          container in-error-other {
                            description
                              "IN ERROR OTHER";
                            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";
                            }
                          }  // container in-error-other

                          container in-pkt64-octet {
                            description
                              "IN PKT 64 OCTET";
                            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";
                            }
                          }  // container in-pkt64-octet

                          container in-pkts65-to127-octets {
                            description
                              "IN PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container in-pkts65-to127-octets

                          container in-pkts128-to255-octets {
                            description
                              "IN PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container in-pkts128-to255-octets

                          container in-pkts256-to511-octets {
                            description
                              "IN PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container in-pkts256-to511-octets

                          container in-pkts512-to1023-octets {
                            description
                              "IN PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container in-pkts512-to1023-octets

                          container in-pkts1024-to1518-octets {
                            description
                              "IN PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container in-pkts1024-to1518-octets

                          container outpkt64octet {
                            description
                              "OUT PKT 64 OCTET";
                            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";
                            }
                          }  // container outpkt64octet

                          container out-pkts65127-octets {
                            description
                              "OUT PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container out-pkts65127-octets

                          container out-pkts128255-octets {
                            description
                              "OUT PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container out-pkts128255-octets

                          container out-pkts256511-octets {
                            description
                              "OUT PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container out-pkts256511-octets

                          container out-pkts5121023-octets {
                            description
                              "OUT PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container out-pkts5121023-octets

                          container out-pkts10241518-octets {
                            description
                              "OUT PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container out-pkts10241518-octets

                          container rx-util {
                            description
                              "Rx Utilization in Percent";
                            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";
                            }
                          }  // container rx-util

                          container tx-util {
                            description
                              "Tx Utilization in Percent";
                            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";
                            }
                          }  // container tx-util

                          container tx-undersized-pkt {
                            description
                              "TX Undersized Pkt";
                            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";
                            }
                          }  // container tx-undersized-pkt

                          container tx-oversized-pkt {
                            description
                              "TX Oversized Pkt";
                            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";
                            }
                          }  // container tx-oversized-pkt

                          container tx-fragments {
                            description
                              "TX Fragments";
                            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";
                            }
                          }  // container tx-fragments

                          container tx-jabber {
                            description
                              "TX Jabber";
                            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";
                            }
                          }  // container tx-jabber

                          container tx-bad-fcs {
                            description
                              "TX Bad Fcs";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list second30-ether-time-line-instance
                      }  // container second30-ether-time-line-instances

                      leaf slot-number {
                        type uint32;
                        description
                          "interval slot number";
                      }
                    }  // list second30-ether-history
                  }  // container second30-ether-histories

                  container second30-fec-histories {
                    description
                      "ETHERNET port interval performance data";
                    list second30-fec-history {
                      key "slot-number";
                      description
                        "ETHERNET port 30 sec fec performance data";
                      container second30-fec-time-line-instances {
                        description
                          "port current performance data";
                        list second30-fec-time-line-instance {
                          key "number";
                          description
                            "port 30 sec fec performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list second30-fec-time-line-instance
                      }  // container second30-fec-time-line-instances

                      leaf slot-number {
                        type uint32;
                        description
                          "interval slot number";
                      }
                    }  // list second30-fec-history
                  }  // container second30-fec-histories
                }  // container ethernet-second30-history

                container ethernet-hour24-history {
                  description
                    "port current performance data";
                  container hour24pcs-histories {
                    description
                      "port current performance data";
                    list hour24pcs-history {
                      key "number";
                      description
                        "port 24 hour ethernet performance data";
                      container hour24pcs-time-line-instances {
                        description
                          "port current performance data";
                        list hour24pcs-time-line-instance {
                          key "number";
                          description
                            "port 24-hour ethernet performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container bip {
                            description
                              "Bip ";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container bip

                          container frm-err {
                            description
                              "Frm Err";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container frm-err

                          container bad-sh {
                            description
                              "Bad Sh";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container bad-sh

                          container es-ne {
                            description
                              "Es Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container es-ne

                          container ses-ne {
                            description
                              "Ses Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container ses-ne

                          container uas-ne {
                            description
                              "Uas Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container uas-ne

                          container es-fe {
                            description
                              "Es Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container es-fe

                          container ses-fe {
                            description
                              "Ese Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container ses-fe

                          container uas-fe {
                            description
                              "Uas Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // 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";
                          }
                        }  // list hour24pcs-time-line-instance
                      }  // container hour24pcs-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list hour24pcs-history
                  }  // container hour24pcs-histories

                  container ethernet-hour24fec-histories {
                    description
                      "port current performance data";
                    list ethernet-hour24fec-history {
                      key "number";
                      description
                        "port 24 hour ethernet performance data";
                      container ethernet-hour24fec-time-line-instances {
                        description
                          "port current performance data";
                        list ethernet-hour24fec-time-line-instance {
                          key "number";
                          description
                            "port 24-hour ethernet performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list ethernet-hour24fec-time-line-instance
                      }  // container ethernet-hour24fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list ethernet-hour24fec-history
                  }  // container ethernet-hour24fec-histories

                  container ethernet-hour24-ether-histories {
                    description
                      "port current performance data";
                    list ethernet-hour24-ether-history {
                      key "number";
                      description
                        "port 24 hour ethernet performance data";
                      container ethernet-hour24-ether-time-line-instances {
                        description
                          "port current performance data";
                        list ethernet-hour24-ether-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container rx-pkt {
                            description
                              "RX PKT";
                            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";
                            }
                          }  // container rx-pkt

                          container stat-pkt {
                            description
                              "STAT PKT";
                            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";
                            }
                          }  // container stat-pkt

                          container octet-stat {
                            description
                              "OCTET STAT";
                            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";
                            }
                          }  // container octet-stat

                          container oversize-pkt-stat {
                            description
                              "OVERSIZE PKT";
                            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";
                            }
                          }  // container oversize-pkt-stat

                          container fcs-errors-stat {
                            description
                              "FCS ERR";
                            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";
                            }
                          }  // container fcs-errors-stat

                          container long-frames-stat {
                            description
                              "LONG FRAMES";
                            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";
                            }
                          }  // container long-frames-stat

                          container jabber-stat {
                            description
                              "JABBER STATS";
                            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";
                            }
                          }  // container jabber-stat

                          container ether64-octets {
                            description
                              "SIXTY FOUR OCTET";
                            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";
                            }
                          }  // container ether64-octets

                          container ether65127-octet {
                            description
                              "OCTET";
                            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";
                            }
                          }  // container ether65127-octet

                          container ether128255-octet {
                            description
                              "TFF OCTET";
                            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";
                            }
                          }  // container ether128255-octet

                          container ether256511-octet {
                            description
                              "FOO OCTET";
                            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";
                            }
                          }  // container ether256511-octet

                          container ether5121023-octet {
                            description
                              "OZTT OCTET";
                            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";
                            }
                          }  // container ether5121023-octet

                          container ether10241518-octet {
                            description
                              "OFO OCTET";
                            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";
                            }
                          }  // container ether10241518-octet

                          container in-ucast-pkt {
                            description
                              "IN UCAST";
                            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";
                            }
                          }  // container in-ucast-pkt

                          container in-mcast-pkt {
                            description
                              "IN MCAST";
                            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";
                            }
                          }  // container in-mcast-pkt

                          container in-bcast-pkt {
                            description
                              "IN BCAST";
                            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";
                            }
                          }  // container in-bcast-pkt

                          container out-ucast-pkt {
                            description
                              "OUT UCAST";
                            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";
                            }
                          }  // container out-ucast-pkt

                          container out-bcast-pkt {
                            description
                              "OUT BCAST";
                            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";
                            }
                          }  // container out-bcast-pkt

                          container out-mcast-pkt {
                            description
                              "OUT MCAST";
                            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";
                            }
                          }  // container out-mcast-pkt

                          container tx-pkt {
                            description
                              "TX PKT";
                            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";
                            }
                          }  // container tx-pkt

                          container if-in-errors {
                            description
                              "IFIN ERRORS";
                            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";
                            }
                          }  // container if-in-errors

                          container if-in-octets {
                            description
                              "IFIN OCTETS";
                            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";
                            }
                          }  // container if-in-octets

                          container ether-stat-multicast-pkt {
                            description
                              "ETHER STAT MULTICAST PKT";
                            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";
                            }
                          }  // container ether-stat-multicast-pkt

                          container ether-stat-broadcast-pkt {
                            description
                              "ETHER STAT BROADCAST PKT";
                            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";
                            }
                          }  // container ether-stat-broadcast-pkt

                          container ether-stat-undersized-pkt {
                            description
                              "ETHER STAT UNDERSIZED PKT";
                            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";
                            }
                          }  // container ether-stat-undersized-pkt

                          container out-octets {
                            description
                              "OUT OCTET";
                            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";
                            }
                          }  // container out-octets

                          container in-pause-frame {
                            description
                              "INPUT PAUSE FRAME";
                            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";
                            }
                          }  // container in-pause-frame

                          container in-good-bytes {
                            description
                              "INPUT GOOD BYTES";
                            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";
                            }
                          }  // container in-good-bytes

                          container in8021q-frames {
                            description
                              "INPUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container in8021q-frames

                          container in-pkts1519-max-octets {
                            description
                              "INPUT PKTS 1519MAX OCTETS";
                            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";
                            }
                          }  // container in-pkts1519-max-octets

                          container in-good-pkts {
                            description
                              "INPUT GOOD PKTS";
                            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";
                            }
                          }  // container in-good-pkts

                          container in-drop-overrun {
                            description
                              "INPUT DROP OVERRUN";
                            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";
                            }
                          }  // container in-drop-overrun

                          container in-drop-abort {
                            description
                              "INPUT DROP ABORT";
                            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";
                            }
                          }  // container in-drop-abort

                          container in-drop-invalid-vlan {
                            description
                              "INPUT DROP INVALID VLAN";
                            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";
                            }
                          }  // container in-drop-invalid-vlan

                          container in-drop-invalid-dmac {
                            description
                              "INPUT DROP INVALID DMAC";
                            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";
                            }
                          }  // container in-drop-invalid-dmac

                          container in-drop-invalid-encap {
                            description
                              "INPUT DROP INVALID ENCAP";
                            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";
                            }
                          }  // container in-drop-invalid-encap

                          container in-drop-other {
                            description
                              "INPUT DROP OTHER";
                            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";
                            }
                          }  // container in-drop-other

                          container in-mib-giant {
                            description
                              "INPUT MIB GIANT";
                            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";
                            }
                          }  // container in-mib-giant

                          container in-mib-jabber {
                            description
                              "INPUT MIB JABBER";
                            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";
                            }
                          }  // container in-mib-jabber

                          container in-mibcrc {
                            description
                              "IN MIB CRC";
                            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";
                            }
                          }  // container in-mibcrc

                          container in-error-collisions {
                            description
                              "IN ERROR COLLISIONS";
                            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";
                            }
                          }  // container in-error-collisions

                          container in-error-symbol {
                            description
                              "IN ERROR SYMBOL";
                            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";
                            }
                          }  // container in-error-symbol

                          container out-good-bytes {
                            description
                              "OUT GOOD BYTES";
                            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";
                            }
                          }  // container out-good-bytes

                          container out8021q-frames {
                            description
                              "OUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container out8021q-frames

                          container out-pause-frames {
                            description
                              "OUT PAUSE FRAMES";
                            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";
                            }
                          }  // container out-pause-frames

                          container out-pkts1519-max-octets {
                            description
                              "OUT PKTS 1519 MAX OCTETS";
                            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";
                            }
                          }  // container out-pkts1519-max-octets

                          container out-good-pkts {
                            description
                              "OUT GOOD PKTS";
                            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";
                            }
                          }  // container out-good-pkts

                          container out-drop-underrun {
                            description
                              "OUT DROP UNDERRUN";
                            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";
                            }
                          }  // container out-drop-underrun

                          container out-drop-abort {
                            description
                              "OUT DROP ABORT";
                            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";
                            }
                          }  // container out-drop-abort

                          container out-drop-other {
                            description
                              "OUT DROP OTHER";
                            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";
                            }
                          }  // container out-drop-other

                          container out-error-other {
                            description
                              "OUT ERROR OTHER";
                            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";
                            }
                          }  // container out-error-other

                          container in-error-giant {
                            description
                              "IN ERROR GIANT";
                            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";
                            }
                          }  // container in-error-giant

                          container in-error-runt {
                            description
                              "IN ERROR RUNT";
                            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";
                            }
                          }  // container in-error-runt

                          container in-error-jabbers {
                            description
                              "IN ERROR JABBERS";
                            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";
                            }
                          }  // container in-error-jabbers

                          container in-error-fragments {
                            description
                              "IN ERROR FRAGMENTS";
                            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";
                            }
                          }  // container in-error-fragments

                          container in-error-other {
                            description
                              "IN ERROR OTHER";
                            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";
                            }
                          }  // container in-error-other

                          container in-pkt64-octet {
                            description
                              "IN PKT 64 OCTET";
                            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";
                            }
                          }  // container in-pkt64-octet

                          container in-pkts65-to127-octets {
                            description
                              "IN PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container in-pkts65-to127-octets

                          container in-pkts128-to255-octets {
                            description
                              "IN PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container in-pkts128-to255-octets

                          container in-pkts256-to511-octets {
                            description
                              "IN PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container in-pkts256-to511-octets

                          container in-pkts512-to1023-octets {
                            description
                              "IN PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container in-pkts512-to1023-octets

                          container in-pkts1024-to1518-octets {
                            description
                              "IN PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container in-pkts1024-to1518-octets

                          container outpkt64octet {
                            description
                              "OUT PKT 64 OCTET";
                            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";
                            }
                          }  // container outpkt64octet

                          container out-pkts65127-octets {
                            description
                              "OUT PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container out-pkts65127-octets

                          container out-pkts128255-octets {
                            description
                              "OUT PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container out-pkts128255-octets

                          container out-pkts256511-octets {
                            description
                              "OUT PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container out-pkts256511-octets

                          container out-pkts5121023-octets {
                            description
                              "OUT PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container out-pkts5121023-octets

                          container out-pkts10241518-octets {
                            description
                              "OUT PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container out-pkts10241518-octets

                          container rx-util {
                            description
                              "Rx Utilization in Percent";
                            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";
                            }
                          }  // container rx-util

                          container tx-util {
                            description
                              "Tx Utilization in Percent";
                            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";
                            }
                          }  // container tx-util

                          container tx-undersized-pkt {
                            description
                              "TX Undersized Pkt";
                            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";
                            }
                          }  // container tx-undersized-pkt

                          container tx-oversized-pkt {
                            description
                              "TX Oversized Pkt";
                            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";
                            }
                          }  // container tx-oversized-pkt

                          container tx-fragments {
                            description
                              "TX Fragments";
                            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";
                            }
                          }  // container tx-fragments

                          container tx-jabber {
                            description
                              "TX Jabber";
                            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";
                            }
                          }  // container tx-jabber

                          container tx-bad-fcs {
                            description
                              "TX Bad Fcs";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list ethernet-hour24-ether-time-line-instance
                      }  // container ethernet-hour24-ether-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list ethernet-hour24-ether-history
                  }  // container ethernet-hour24-ether-histories
                }  // container ethernet-hour24-history

                container ethernet-minute15-history {
                  description
                    "port current performance data";
                  container minute15pcs-histories {
                    description
                      "ETHERNET port interval performance data";
                    list minute15pcs-history {
                      key "slot-number";
                      description
                        "ETHERNET port 15-minute pcs performance
                       data";
                      container minute15pcs-time-line-instances {
                        description
                          "port current performance data";
                        list minute15pcs-time-line-instance {
                          key "number";
                          description
                            "port 15-minute pcs performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container bip {
                            description
                              "Bip ";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container bip

                          container frm-err {
                            description
                              "Frm Err";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container frm-err

                          container bad-sh {
                            description
                              "Bad Sh";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container bad-sh

                          container es-ne {
                            description
                              "Es Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container es-ne

                          container ses-ne {
                            description
                              "Ses Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container ses-ne

                          container uas-ne {
                            description
                              "Uas Ne";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container uas-ne

                          container es-fe {
                            description
                              "Es Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container es-fe

                          container ses-fe {
                            description
                              "Ese Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // container ses-fe

                          container uas-fe {
                            description
                              "Uas Fe";
                            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";
                              leaf name {
                                type string {
                                  length
                                    "0..19";
                                }
                                description
                                  "pcs param name";
                              }

                              leaf data {
                                type uint64;
                                description
                                  "the threshold users set";
                              }
                            }  // list count
                          }  // 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";
                          }
                        }  // list minute15pcs-time-line-instance
                      }  // container minute15pcs-time-line-instances

                      leaf slot-number {
                        type uint32;
                        description
                          "interval slot number";
                      }
                    }  // list minute15pcs-history
                  }  // container minute15pcs-histories

                  container minute15-ether-histories {
                    description
                      "ETHERNET port interval performance data";
                    list minute15-ether-history {
                      key "slot-number";
                      description
                        "ETHERNET port 15-minute ether performance
                       data";
                      container minute15-ether-time-line-instances {
                        description
                          "port current performance data";
                        list minute15-ether-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container rx-pkt {
                            description
                              "RX PKT";
                            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";
                            }
                          }  // container rx-pkt

                          container stat-pkt {
                            description
                              "STAT PKT";
                            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";
                            }
                          }  // container stat-pkt

                          container octet-stat {
                            description
                              "OCTET STAT";
                            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";
                            }
                          }  // container octet-stat

                          container oversize-pkt-stat {
                            description
                              "OVERSIZE PKT";
                            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";
                            }
                          }  // container oversize-pkt-stat

                          container fcs-errors-stat {
                            description
                              "FCS ERR";
                            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";
                            }
                          }  // container fcs-errors-stat

                          container long-frames-stat {
                            description
                              "LONG FRAMES";
                            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";
                            }
                          }  // container long-frames-stat

                          container jabber-stat {
                            description
                              "JABBER STATS";
                            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";
                            }
                          }  // container jabber-stat

                          container ether64-octets {
                            description
                              "SIXTY FOUR OCTET";
                            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";
                            }
                          }  // container ether64-octets

                          container ether65127-octet {
                            description
                              "OCTET";
                            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";
                            }
                          }  // container ether65127-octet

                          container ether128255-octet {
                            description
                              "TFF OCTET";
                            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";
                            }
                          }  // container ether128255-octet

                          container ether256511-octet {
                            description
                              "FOO OCTET";
                            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";
                            }
                          }  // container ether256511-octet

                          container ether5121023-octet {
                            description
                              "OZTT OCTET";
                            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";
                            }
                          }  // container ether5121023-octet

                          container ether10241518-octet {
                            description
                              "OFO OCTET";
                            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";
                            }
                          }  // container ether10241518-octet

                          container in-ucast-pkt {
                            description
                              "IN UCAST";
                            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";
                            }
                          }  // container in-ucast-pkt

                          container in-mcast-pkt {
                            description
                              "IN MCAST";
                            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";
                            }
                          }  // container in-mcast-pkt

                          container in-bcast-pkt {
                            description
                              "IN BCAST";
                            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";
                            }
                          }  // container in-bcast-pkt

                          container out-ucast-pkt {
                            description
                              "OUT UCAST";
                            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";
                            }
                          }  // container out-ucast-pkt

                          container out-bcast-pkt {
                            description
                              "OUT BCAST";
                            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";
                            }
                          }  // container out-bcast-pkt

                          container out-mcast-pkt {
                            description
                              "OUT MCAST";
                            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";
                            }
                          }  // container out-mcast-pkt

                          container tx-pkt {
                            description
                              "TX PKT";
                            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";
                            }
                          }  // container tx-pkt

                          container if-in-errors {
                            description
                              "IFIN ERRORS";
                            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";
                            }
                          }  // container if-in-errors

                          container if-in-octets {
                            description
                              "IFIN OCTETS";
                            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";
                            }
                          }  // container if-in-octets

                          container ether-stat-multicast-pkt {
                            description
                              "ETHER STAT MULTICAST PKT";
                            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";
                            }
                          }  // container ether-stat-multicast-pkt

                          container ether-stat-broadcast-pkt {
                            description
                              "ETHER STAT BROADCAST PKT";
                            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";
                            }
                          }  // container ether-stat-broadcast-pkt

                          container ether-stat-undersized-pkt {
                            description
                              "ETHER STAT UNDERSIZED PKT";
                            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";
                            }
                          }  // container ether-stat-undersized-pkt

                          container out-octets {
                            description
                              "OUT OCTET";
                            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";
                            }
                          }  // container out-octets

                          container in-pause-frame {
                            description
                              "INPUT PAUSE FRAME";
                            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";
                            }
                          }  // container in-pause-frame

                          container in-good-bytes {
                            description
                              "INPUT GOOD BYTES";
                            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";
                            }
                          }  // container in-good-bytes

                          container in8021q-frames {
                            description
                              "INPUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container in8021q-frames

                          container in-pkts1519-max-octets {
                            description
                              "INPUT PKTS 1519MAX OCTETS";
                            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";
                            }
                          }  // container in-pkts1519-max-octets

                          container in-good-pkts {
                            description
                              "INPUT GOOD PKTS";
                            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";
                            }
                          }  // container in-good-pkts

                          container in-drop-overrun {
                            description
                              "INPUT DROP OVERRUN";
                            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";
                            }
                          }  // container in-drop-overrun

                          container in-drop-abort {
                            description
                              "INPUT DROP ABORT";
                            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";
                            }
                          }  // container in-drop-abort

                          container in-drop-invalid-vlan {
                            description
                              "INPUT DROP INVALID VLAN";
                            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";
                            }
                          }  // container in-drop-invalid-vlan

                          container in-drop-invalid-dmac {
                            description
                              "INPUT DROP INVALID DMAC";
                            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";
                            }
                          }  // container in-drop-invalid-dmac

                          container in-drop-invalid-encap {
                            description
                              "INPUT DROP INVALID ENCAP";
                            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";
                            }
                          }  // container in-drop-invalid-encap

                          container in-drop-other {
                            description
                              "INPUT DROP OTHER";
                            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";
                            }
                          }  // container in-drop-other

                          container in-mib-giant {
                            description
                              "INPUT MIB GIANT";
                            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";
                            }
                          }  // container in-mib-giant

                          container in-mib-jabber {
                            description
                              "INPUT MIB JABBER";
                            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";
                            }
                          }  // container in-mib-jabber

                          container in-mibcrc {
                            description
                              "IN MIB CRC";
                            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";
                            }
                          }  // container in-mibcrc

                          container in-error-collisions {
                            description
                              "IN ERROR COLLISIONS";
                            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";
                            }
                          }  // container in-error-collisions

                          container in-error-symbol {
                            description
                              "IN ERROR SYMBOL";
                            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";
                            }
                          }  // container in-error-symbol

                          container out-good-bytes {
                            description
                              "OUT GOOD BYTES";
                            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";
                            }
                          }  // container out-good-bytes

                          container out8021q-frames {
                            description
                              "OUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container out8021q-frames

                          container out-pause-frames {
                            description
                              "OUT PAUSE FRAMES";
                            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";
                            }
                          }  // container out-pause-frames

                          container out-pkts1519-max-octets {
                            description
                              "OUT PKTS 1519 MAX OCTETS";
                            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";
                            }
                          }  // container out-pkts1519-max-octets

                          container out-good-pkts {
                            description
                              "OUT GOOD PKTS";
                            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";
                            }
                          }  // container out-good-pkts

                          container out-drop-underrun {
                            description
                              "OUT DROP UNDERRUN";
                            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";
                            }
                          }  // container out-drop-underrun

                          container out-drop-abort {
                            description
                              "OUT DROP ABORT";
                            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";
                            }
                          }  // container out-drop-abort

                          container out-drop-other {
                            description
                              "OUT DROP OTHER";
                            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";
                            }
                          }  // container out-drop-other

                          container out-error-other {
                            description
                              "OUT ERROR OTHER";
                            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";
                            }
                          }  // container out-error-other

                          container in-error-giant {
                            description
                              "IN ERROR GIANT";
                            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";
                            }
                          }  // container in-error-giant

                          container in-error-runt {
                            description
                              "IN ERROR RUNT";
                            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";
                            }
                          }  // container in-error-runt

                          container in-error-jabbers {
                            description
                              "IN ERROR JABBERS";
                            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";
                            }
                          }  // container in-error-jabbers

                          container in-error-fragments {
                            description
                              "IN ERROR FRAGMENTS";
                            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";
                            }
                          }  // container in-error-fragments

                          container in-error-other {
                            description
                              "IN ERROR OTHER";
                            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";
                            }
                          }  // container in-error-other

                          container in-pkt64-octet {
                            description
                              "IN PKT 64 OCTET";
                            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";
                            }
                          }  // container in-pkt64-octet

                          container in-pkts65-to127-octets {
                            description
                              "IN PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container in-pkts65-to127-octets

                          container in-pkts128-to255-octets {
                            description
                              "IN PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container in-pkts128-to255-octets

                          container in-pkts256-to511-octets {
                            description
                              "IN PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container in-pkts256-to511-octets

                          container in-pkts512-to1023-octets {
                            description
                              "IN PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container in-pkts512-to1023-octets

                          container in-pkts1024-to1518-octets {
                            description
                              "IN PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container in-pkts1024-to1518-octets

                          container outpkt64octet {
                            description
                              "OUT PKT 64 OCTET";
                            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";
                            }
                          }  // container outpkt64octet

                          container out-pkts65127-octets {
                            description
                              "OUT PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container out-pkts65127-octets

                          container out-pkts128255-octets {
                            description
                              "OUT PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container out-pkts128255-octets

                          container out-pkts256511-octets {
                            description
                              "OUT PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container out-pkts256511-octets

                          container out-pkts5121023-octets {
                            description
                              "OUT PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container out-pkts5121023-octets

                          container out-pkts10241518-octets {
                            description
                              "OUT PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container out-pkts10241518-octets

                          container rx-util {
                            description
                              "Rx Utilization in Percent";
                            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";
                            }
                          }  // container rx-util

                          container tx-util {
                            description
                              "Tx Utilization in Percent";
                            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";
                            }
                          }  // container tx-util

                          container tx-undersized-pkt {
                            description
                              "TX Undersized Pkt";
                            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";
                            }
                          }  // container tx-undersized-pkt

                          container tx-oversized-pkt {
                            description
                              "TX Oversized Pkt";
                            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";
                            }
                          }  // container tx-oversized-pkt

                          container tx-fragments {
                            description
                              "TX Fragments";
                            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";
                            }
                          }  // container tx-fragments

                          container tx-jabber {
                            description
                              "TX Jabber";
                            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";
                            }
                          }  // container tx-jabber

                          container tx-bad-fcs {
                            description
                              "TX Bad Fcs";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list minute15-ether-time-line-instance
                      }  // container minute15-ether-time-line-instances

                      leaf slot-number {
                        type uint32;
                        description
                          "interval slot number";
                      }
                    }  // list minute15-ether-history
                  }  // container minute15-ether-histories

                  container minute15-fec-histories {
                    description
                      "ETHERNET port interval performance data";
                    list minute15-fec-history {
                      key "slot-number";
                      description
                        "ETHERNET port 15-minute fec performance
                       data";
                      container minute15-fec-time-line-instances {
                        description
                          "port current performance data";
                        list minute15-fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list minute15-fec-time-line-instance
                      }  // container minute15-fec-time-line-instances

                      leaf slot-number {
                        type uint32;
                        description
                          "interval slot number";
                      }
                    }  // list minute15-fec-history
                  }  // container minute15-fec-histories
                }  // container ethernet-minute15-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list ethernet-port-history
            }  // container ethernet-port-histories
          }  // container ethernet-history

          container dwdm-history {
            description
              "DWDM controller History performance data";
            container dwdm-port-histories {
              description
                "Port performance data";
              list dwdm-port-history {
                key "name";
                description
                  "Port performance data";
                container dwdm-minute15-history {
                  description
                    "port current performance data";
                  container dwdm-minute15otn-histories {
                    description
                      "port current performance data";
                    list dwdm-minute15otn-history {
                      key "number";
                      description
                        "port 15-minute otn performance data";
                      container dwdm-minute15otn-time-line-instances {
                        description
                          "port current performance data";
                        list dwdm-minute15otn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list dwdm-minute15otn-time-line-instance
                      }  // container dwdm-minute15otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list dwdm-minute15otn-history
                  }  // container dwdm-minute15otn-histories

                  container dwdm-minute15fec-histories {
                    description
                      "port current performance data";
                    list dwdm-minute15fec-history {
                      key "number";
                      description
                        "port 15-minute fec performance data";
                      container dwdm-minute15fec-time-line-instances {
                        description
                          "port current performance data";
                        list dwdm-minute15fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data by
                           index";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list dwdm-minute15fec-time-line-instance
                      }  // container dwdm-minute15fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list dwdm-minute15fec-history
                  }  // container dwdm-minute15fec-histories

                  container dwdm-minute15-optics-histories {
                    description
                      "port current performance data";
                    list dwdm-minute15-optics-history {
                      key "number";
                      description
                        "port 15-minute optics performance data";
                      container dwdm-minute15-optics-time-line-instances {
                        description
                          "port current performance data";
                        list dwdm-minute15-optics-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container lbc-pc {
                            description
                              "LBC in percentage";
                            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";
                            }
                          }  // container lbc-pc

                          container opt {
                            description
                              "OPT";
                            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";
                            }
                          }  // container opt

                          container opr {
                            description
                              "OPR";
                            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";
                            }
                          }  // container opr

                          container cd {
                            description
                              "Chromatic Dispersion";
                            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";
                            }
                          }  // container cd

                          container dgd {
                            description
                              "Differential group Delay";
                            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";
                            }
                          }  // container dgd

                          container pmd {
                            description
                              "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                            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";
                            }
                          }  // container pmd

                          container sopmd {
                            description
                              "Second order Polarization Mode Dispersion";
                            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";
                            }
                          }  // container sopmd

                          container osnr {
                            description
                              "Optical Signal to Noise Ratio";
                            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";
                            }
                          }  // container osnr

                          container center-wavelength {
                            description
                              "Center Wavelength/Frequency";
                            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";
                            }
                          }  // container center-wavelength

                          container pdl {
                            description
                              "Polarization Dependent Loss";
                            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";
                            }
                          }  // container pdl

                          container pcr {
                            description
                              "Polarization Change Rate";
                            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";
                            }
                          }  // container pcr

                          container pn {
                            description
                              "Phase Noise";
                            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";
                            }
                          }  // container pn

                          container rx-sig-pow {
                            description
                              "Rx signal power";
                            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";
                            }
                          }  // container rx-sig-pow

                          container low-sig-freq-off {
                            description
                              "low freq sig off";
                            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";
                            }
                          }  // container low-sig-freq-off

                          container ampli-gain {
                            description
                              "Ampli Gain";
                            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";
                            }
                          }  // container ampli-gain

                          container ampli-gain-tilt {
                            description
                              "Ampli Gain Tilt";
                            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";
                            }
                          }  // container ampli-gain-tilt

                          container snr {
                            description
                              "SNR";
                            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";
                            }
                          }  // container snr

                          container snrax {
                            description
                              "SNR AX";
                            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";
                            }
                          }  // container snrax

                          container snrbx {
                            description
                              "SNR BX";
                            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";
                            }
                          }  // container snrbx

                          container snray {
                            description
                              "SNR AY";
                            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";
                            }
                          }  // container snray

                          container snrby {
                            description
                              "SNR BY";
                            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";
                            }
                          }  // container snrby

                          container sops1 {
                            description
                              "SOP S1";
                            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";
                            }
                          }  // container sops1

                          container sops2 {
                            description
                              "SOP S2";
                            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";
                            }
                          }  // container sops2

                          container sops3 {
                            description
                              "SOP S3";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list dwdm-minute15-optics-time-line-instance
                      }  // container dwdm-minute15-optics-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list dwdm-minute15-optics-history
                  }  // container dwdm-minute15-optics-histories
                }  // container dwdm-minute15-history

                container dwdm-hour24-history {
                  description
                    "port current performance data";
                  container dwdm-hour24otn-histories {
                    description
                      "port 24 hour performance data";
                    list dwdm-hour24otn-history {
                      key "number";
                      description
                        "port 24 hour otn performance data";
                      container dwdm-hour24otn-time-line-instances {
                        description
                          "port current performance data";
                        list dwdm-hour24otn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list dwdm-hour24otn-time-line-instance
                      }  // container dwdm-hour24otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list dwdm-hour24otn-history
                  }  // container dwdm-hour24otn-histories

                  container dwdm-hour24fec-histories {
                    description
                      "port current performance data";
                    list dwdm-hour24fec-history {
                      key "number";
                      description
                        "port 24 hour fec performance data";
                      container dwdm-hour24fec-time-line-instances {
                        description
                          "port current performance data";
                        list dwdm-hour24fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data by
                           index";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list dwdm-hour24fec-time-line-instance
                      }  // container dwdm-hour24fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list dwdm-hour24fec-history
                  }  // container dwdm-hour24fec-histories

                  container dwdm-hour24-optics-histories {
                    description
                      "port 24 hour performance data";
                    list dwdm-hour24-optics-history {
                      key "number";
                      description
                        "port 24 hour optics performance data";
                      container dwdm-hour24-optics-time-line-instances {
                        description
                          "port current performance data";
                        list dwdm-hour24-optics-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container lbc-pc {
                            description
                              "LBC in percentage";
                            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";
                            }
                          }  // container lbc-pc

                          container opt {
                            description
                              "OPT";
                            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";
                            }
                          }  // container opt

                          container opr {
                            description
                              "OPR";
                            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";
                            }
                          }  // container opr

                          container cd {
                            description
                              "Chromatic Dispersion";
                            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";
                            }
                          }  // container cd

                          container dgd {
                            description
                              "Differential group Delay";
                            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";
                            }
                          }  // container dgd

                          container pmd {
                            description
                              "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                            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";
                            }
                          }  // container pmd

                          container sopmd {
                            description
                              "Second order Polarization Mode Dispersion";
                            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";
                            }
                          }  // container sopmd

                          container osnr {
                            description
                              "Optical Signal to Noise Ratio";
                            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";
                            }
                          }  // container osnr

                          container center-wavelength {
                            description
                              "Center Wavelength/Frequency";
                            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";
                            }
                          }  // container center-wavelength

                          container pdl {
                            description
                              "Polarization Dependent Loss";
                            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";
                            }
                          }  // container pdl

                          container pcr {
                            description
                              "Polarization Change Rate";
                            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";
                            }
                          }  // container pcr

                          container pn {
                            description
                              "Phase Noise";
                            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";
                            }
                          }  // container pn

                          container rx-sig-pow {
                            description
                              "Rx signal power";
                            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";
                            }
                          }  // container rx-sig-pow

                          container low-sig-freq-off {
                            description
                              "low freq sig off";
                            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";
                            }
                          }  // container low-sig-freq-off

                          container ampli-gain {
                            description
                              "Ampli Gain";
                            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";
                            }
                          }  // container ampli-gain

                          container ampli-gain-tilt {
                            description
                              "Ampli Gain Tilt";
                            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";
                            }
                          }  // container ampli-gain-tilt

                          container snr {
                            description
                              "SNR";
                            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";
                            }
                          }  // container snr

                          container snrax {
                            description
                              "SNR AX";
                            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";
                            }
                          }  // container snrax

                          container snrbx {
                            description
                              "SNR BX";
                            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";
                            }
                          }  // container snrbx

                          container snray {
                            description
                              "SNR AY";
                            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";
                            }
                          }  // container snray

                          container snrby {
                            description
                              "SNR BY";
                            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";
                            }
                          }  // container snrby

                          container sops1 {
                            description
                              "SOP S1";
                            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";
                            }
                          }  // container sops1

                          container sops2 {
                            description
                              "SOP S2";
                            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";
                            }
                          }  // container sops2

                          container sops3 {
                            description
                              "SOP S3";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list dwdm-hour24-optics-time-line-instance
                      }  // container dwdm-hour24-optics-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list dwdm-hour24-optics-history
                  }  // container dwdm-hour24-optics-histories
                }  // container dwdm-hour24-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list dwdm-port-history
            }  // container dwdm-port-histories
          }  // container dwdm-history

          container stm-history {
            description
              "STM controller History performance data";
            container stm-port-histories {
              description
                "Port performance data";
              list stm-port-history {
                key "name";
                description
                  "Port performance data";
                container stm-hour24-history {
                  description
                    "port current performance data";
                  container stm-hour24stm-histories {
                    description
                      "port current performance data";
                    list stm-hour24stm-history {
                      key "number";
                      description
                        "port 24 hour stm performance data";
                      container stm-hour24stm-time-line-instances {
                        description
                          "port current performance data";
                        list stm-hour24stm-time-line-instance {
                          key "number";
                          description
                            "port 15-minute stm performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container section {
                            description
                              "SECTION";
                            container section-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container section-e-ss

                            container section-es-rs {
                              description
                                "The number of Errored Seconds Ratio";
                              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";
                              }
                            }  // container section-es-rs

                            container section-bb-es {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container section-bb-es

                            container section-bbe-rs {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container section-bbe-rs

                            container section-se-ss {
                              description
                                "The number of Severely Errored Second";
                              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";
                              }
                            }  // container section-se-ss

                            container section-ses-rs {
                              description
                                "The number of Severely Errored Second Ratio";
                              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";
                              }
                            }  // container section-ses-rs

                            container section-ua-ss {
                              description
                                "The number of Unavailable Second";
                              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";
                              }
                            }  // container section-ua-ss

                            container section-e-bs {
                              description
                                "The number of Errored Block Second";
                              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";
                              }
                            }  // container section-e-bs

                            leaf section-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container section

                          container line {
                            description
                              "LINE";
                            container line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container line-e-ss

                            container line-es-rs {
                              description
                                "The number of Errored Seconds Ratio";
                              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";
                              }
                            }  // container line-es-rs

                            container line-bb-es {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container line-bb-es

                            container line-bbe-rs {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container line-bbe-rs

                            container line-se-ss {
                              description
                                "The number of Severely Errored Second";
                              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";
                              }
                            }  // container line-se-ss

                            container line-ses-rs {
                              description
                                "The number of Severely Errored Second Ratio";
                              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";
                              }
                            }  // container line-ses-rs

                            container line-ua-ss {
                              description
                                "The number of Unavailable Second";
                              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";
                              }
                            }  // container line-ua-ss

                            container line-e-bs {
                              description
                                "The number of Errored Block Second";
                              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";
                              }
                            }  // container line-e-bs

                            leaf line-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container line

                          container fe-line {
                            description
                              "FarEnd LINE";
                            container far-end-line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-e-ss

                            container far-end-line-es-rs {
                              description
                                "The number of Errored Seconds Ratio";
                              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";
                              }
                            }  // container far-end-line-es-rs

                            container far-end-line-ebb-es {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container far-end-line-ebb-es

                            container far-end-line-bbe-rs {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container far-end-line-bbe-rs

                            container far-end-line-se-ss {
                              description
                                "The number of Severely Errored Second";
                              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";
                              }
                            }  // container far-end-line-se-ss

                            container far-end-line-ses-rs {
                              description
                                "The number of Severely Errored Second Ratio";
                              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";
                              }
                            }  // container far-end-line-ses-rs

                            container far-end-line-ua-ss {
                              description
                                "The number of Unavailable Second";
                              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";
                              }
                            }  // container far-end-line-ua-ss

                            container far-end-line-e-bs {
                              description
                                "The number of Errored Block Second";
                              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";
                              }
                            }  // container far-end-line-e-bs
                          }  // 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";
                          }
                        }  // list stm-hour24stm-time-line-instance
                      }  // container stm-hour24stm-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list stm-hour24stm-history
                  }  // container stm-hour24stm-histories
                }  // container stm-hour24-history

                container stm-minute15-history {
                  description
                    "port current performance data";
                  container stm-minute15stm-histories {
                    description
                      "port current performance data";
                    list stm-minute15stm-history {
                      key "number";
                      description
                        "port 15-minute stm performance data";
                      container stm-minute15stm-time-line-instances {
                        description
                          "port current performance data";
                        list stm-minute15stm-time-line-instance {
                          key "number";
                          description
                            "port 15-minute stm performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container section {
                            description
                              "SECTION";
                            container section-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container section-e-ss

                            container section-es-rs {
                              description
                                "The number of Errored Seconds Ratio";
                              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";
                              }
                            }  // container section-es-rs

                            container section-bb-es {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container section-bb-es

                            container section-bbe-rs {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container section-bbe-rs

                            container section-se-ss {
                              description
                                "The number of Severely Errored Second";
                              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";
                              }
                            }  // container section-se-ss

                            container section-ses-rs {
                              description
                                "The number of Severely Errored Second Ratio";
                              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";
                              }
                            }  // container section-ses-rs

                            container section-ua-ss {
                              description
                                "The number of Unavailable Second";
                              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";
                              }
                            }  // container section-ua-ss

                            container section-e-bs {
                              description
                                "The number of Errored Block Second";
                              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";
                              }
                            }  // container section-e-bs

                            leaf section-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container section

                          container line {
                            description
                              "LINE";
                            container line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container line-e-ss

                            container line-es-rs {
                              description
                                "The number of Errored Seconds Ratio";
                              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";
                              }
                            }  // container line-es-rs

                            container line-bb-es {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container line-bb-es

                            container line-bbe-rs {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container line-bbe-rs

                            container line-se-ss {
                              description
                                "The number of Severely Errored Second";
                              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";
                              }
                            }  // container line-se-ss

                            container line-ses-rs {
                              description
                                "The number of Severely Errored Second Ratio";
                              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";
                              }
                            }  // container line-ses-rs

                            container line-ua-ss {
                              description
                                "The number of Unavailable Second";
                              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";
                              }
                            }  // container line-ua-ss

                            container line-e-bs {
                              description
                                "The number of Errored Block Second";
                              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";
                              }
                            }  // container line-e-bs

                            leaf line-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container line

                          container fe-line {
                            description
                              "FarEnd LINE";
                            container far-end-line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-e-ss

                            container far-end-line-es-rs {
                              description
                                "The number of Errored Seconds Ratio";
                              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";
                              }
                            }  // container far-end-line-es-rs

                            container far-end-line-ebb-es {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container far-end-line-ebb-es

                            container far-end-line-bbe-rs {
                              description
                                "The number of Background Block Errors";
                              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";
                              }
                            }  // container far-end-line-bbe-rs

                            container far-end-line-se-ss {
                              description
                                "The number of Severely Errored Second";
                              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";
                              }
                            }  // container far-end-line-se-ss

                            container far-end-line-ses-rs {
                              description
                                "The number of Severely Errored Second Ratio";
                              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";
                              }
                            }  // container far-end-line-ses-rs

                            container far-end-line-ua-ss {
                              description
                                "The number of Unavailable Second";
                              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";
                              }
                            }  // container far-end-line-ua-ss

                            container far-end-line-e-bs {
                              description
                                "The number of Errored Block Second";
                              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";
                              }
                            }  // container far-end-line-e-bs
                          }  // 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";
                          }
                        }  // list stm-minute15stm-time-line-instance
                      }  // container stm-minute15stm-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list stm-minute15stm-history
                  }  // container stm-minute15stm-histories
                }  // container stm-minute15-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list stm-port-history
            }  // container stm-port-histories
          }  // container stm-history

          container macsec-history {
            description
              "MACSEC controller History performance data";
            container macsec-port-histories {
              description
                "Port performance data";
              list macsec-port-history {
                key "name";
                description
                  "Port performance data";
                container macsec-minute15-history {
                  description
                    "port current performance data";
                  container macsec-minute15secyrx-histories {
                    description
                      "port current performance data";
                    list macsec-minute15secyrx-history {
                      key "number";
                      description
                        "port 15-minute secy_rx performance data";
                      container macsec-minute15secyrx-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-minute15secyrx-time-line-instance {
                          key "number";
                          description
                            "port 15-minute secy_rx performance data
                           by index";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container in-pkts-unchecked {
                            description
                              "In Packet Unchecked";
                            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";
                            }
                          }  // container in-pkts-unchecked

                          container in-pkts-delayed {
                            description
                              "In Packet Delay";
                            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";
                            }
                          }  // container in-pkts-delayed

                          container in-pkts-late {
                            description
                              "In Packet Late";
                            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";
                            }
                          }  // container in-pkts-late

                          container in-pkts-ok {
                            description
                              "In Packet Ok";
                            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";
                            }
                          }  // container in-pkts-ok

                          container in-pkts-invalid {
                            description
                              "In Packet Invalid";
                            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";
                            }
                          }  // container in-pkts-invalid

                          container in-pkts-not-valid {
                            description
                              "In Packet Not Valid";
                            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";
                            }
                          }  // container in-pkts-not-valid

                          container in-pkts-not-using-sa {
                            description
                              "In Packet Not Using SA";
                            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";
                            }
                          }  // container in-pkts-not-using-sa

                          container in-pkts-unused-sa {
                            description
                              "In Packet Unused SA";
                            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";
                            }
                          }  // container in-pkts-unused-sa

                          container in-pkts-untagged-hit {
                            description
                              "In Packet Untagged Hit";
                            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";
                            }
                          }  // container in-pkts-untagged-hit

                          container in-octets-validated {
                            description
                              "In Octet Validated";
                            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";
                            }
                          }  // container in-octets-validated

                          container in-octets-decrypted {
                            description
                              "In Octet Decrypted";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-minute15secyrx-time-line-instance
                      }  // container macsec-minute15secyrx-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-minute15secyrx-history
                  }  // container macsec-minute15secyrx-histories

                  container macsec-minute15-ether-histories {
                    description
                      "port current performance data";
                    list macsec-minute15-ether-history {
                      key "number";
                      description
                        "port 15-minute ether performance data";
                      container macsec-minute15-ether-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-minute15-ether-time-line-instance {
                          key "number";
                          description
                            "port 15-minute ether performance data
                           by index";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container rx-pkt {
                            description
                              "RX PKT";
                            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";
                            }
                          }  // container rx-pkt

                          container stat-pkt {
                            description
                              "STAT PKT";
                            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";
                            }
                          }  // container stat-pkt

                          container octet-stat {
                            description
                              "OCTET STAT";
                            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";
                            }
                          }  // container octet-stat

                          container oversize-pkt-stat {
                            description
                              "OVERSIZE PKT";
                            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";
                            }
                          }  // container oversize-pkt-stat

                          container fcs-errors-stat {
                            description
                              "FCS ERR";
                            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";
                            }
                          }  // container fcs-errors-stat

                          container long-frames-stat {
                            description
                              "LONG FRAMES";
                            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";
                            }
                          }  // container long-frames-stat

                          container jabber-stat {
                            description
                              "JABBER STATS";
                            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";
                            }
                          }  // container jabber-stat

                          container ether64-octets {
                            description
                              "SIXTY FOUR OCTET";
                            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";
                            }
                          }  // container ether64-octets

                          container ether65127-octet {
                            description
                              "OCTET";
                            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";
                            }
                          }  // container ether65127-octet

                          container ether128255-octet {
                            description
                              "TFF OCTET";
                            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";
                            }
                          }  // container ether128255-octet

                          container ether256511-octet {
                            description
                              "FOO OCTET";
                            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";
                            }
                          }  // container ether256511-octet

                          container ether5121023-octet {
                            description
                              "OZTT OCTET";
                            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";
                            }
                          }  // container ether5121023-octet

                          container ether10241518-octet {
                            description
                              "OFO OCTET";
                            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";
                            }
                          }  // container ether10241518-octet

                          container in-ucast-pkt {
                            description
                              "IN UCAST";
                            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";
                            }
                          }  // container in-ucast-pkt

                          container in-mcast-pkt {
                            description
                              "IN MCAST";
                            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";
                            }
                          }  // container in-mcast-pkt

                          container in-bcast-pkt {
                            description
                              "IN BCAST";
                            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";
                            }
                          }  // container in-bcast-pkt

                          container out-ucast-pkt {
                            description
                              "OUT UCAST";
                            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";
                            }
                          }  // container out-ucast-pkt

                          container out-bcast-pkt {
                            description
                              "OUT BCAST";
                            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";
                            }
                          }  // container out-bcast-pkt

                          container out-mcast-pkt {
                            description
                              "OUT MCAST";
                            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";
                            }
                          }  // container out-mcast-pkt

                          container tx-pkt {
                            description
                              "TX PKT";
                            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";
                            }
                          }  // container tx-pkt

                          container if-in-errors {
                            description
                              "IFIN ERRORS";
                            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";
                            }
                          }  // container if-in-errors

                          container if-in-octets {
                            description
                              "IFIN OCTETS";
                            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";
                            }
                          }  // container if-in-octets

                          container ether-stat-multicast-pkt {
                            description
                              "ETHER STAT MULTICAST PKT";
                            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";
                            }
                          }  // container ether-stat-multicast-pkt

                          container ether-stat-broadcast-pkt {
                            description
                              "ETHER STAT BROADCAST PKT";
                            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";
                            }
                          }  // container ether-stat-broadcast-pkt

                          container ether-stat-undersized-pkt {
                            description
                              "ETHER STAT UNDERSIZED PKT";
                            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";
                            }
                          }  // container ether-stat-undersized-pkt

                          container out-octets {
                            description
                              "OUT OCTET";
                            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";
                            }
                          }  // container out-octets

                          container in-pause-frame {
                            description
                              "INPUT PAUSE FRAME";
                            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";
                            }
                          }  // container in-pause-frame

                          container in-good-bytes {
                            description
                              "INPUT GOOD BYTES";
                            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";
                            }
                          }  // container in-good-bytes

                          container in8021q-frames {
                            description
                              "INPUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container in8021q-frames

                          container in-pkts1519-max-octets {
                            description
                              "INPUT PKTS 1519MAX OCTETS";
                            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";
                            }
                          }  // container in-pkts1519-max-octets

                          container in-good-pkts {
                            description
                              "INPUT GOOD PKTS";
                            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";
                            }
                          }  // container in-good-pkts

                          container in-drop-overrun {
                            description
                              "INPUT DROP OVERRUN";
                            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";
                            }
                          }  // container in-drop-overrun

                          container in-drop-abort {
                            description
                              "INPUT DROP ABORT";
                            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";
                            }
                          }  // container in-drop-abort

                          container in-drop-invalid-vlan {
                            description
                              "INPUT DROP INVALID VLAN";
                            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";
                            }
                          }  // container in-drop-invalid-vlan

                          container in-drop-invalid-dmac {
                            description
                              "INPUT DROP INVALID DMAC";
                            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";
                            }
                          }  // container in-drop-invalid-dmac

                          container in-drop-invalid-encap {
                            description
                              "INPUT DROP INVALID ENCAP";
                            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";
                            }
                          }  // container in-drop-invalid-encap

                          container in-drop-other {
                            description
                              "INPUT DROP OTHER";
                            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";
                            }
                          }  // container in-drop-other

                          container in-mib-giant {
                            description
                              "INPUT MIB GIANT";
                            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";
                            }
                          }  // container in-mib-giant

                          container in-mib-jabber {
                            description
                              "INPUT MIB JABBER";
                            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";
                            }
                          }  // container in-mib-jabber

                          container in-mibcrc {
                            description
                              "IN MIB CRC";
                            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";
                            }
                          }  // container in-mibcrc

                          container in-error-collisions {
                            description
                              "IN ERROR COLLISIONS";
                            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";
                            }
                          }  // container in-error-collisions

                          container in-error-symbol {
                            description
                              "IN ERROR SYMBOL";
                            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";
                            }
                          }  // container in-error-symbol

                          container out-good-bytes {
                            description
                              "OUT GOOD BYTES";
                            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";
                            }
                          }  // container out-good-bytes

                          container out8021q-frames {
                            description
                              "OUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container out8021q-frames

                          container out-pause-frames {
                            description
                              "OUT PAUSE FRAMES";
                            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";
                            }
                          }  // container out-pause-frames

                          container out-pkts1519-max-octets {
                            description
                              "OUT PKTS 1519 MAX OCTETS";
                            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";
                            }
                          }  // container out-pkts1519-max-octets

                          container out-good-pkts {
                            description
                              "OUT GOOD PKTS";
                            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";
                            }
                          }  // container out-good-pkts

                          container out-drop-underrun {
                            description
                              "OUT DROP UNDERRUN";
                            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";
                            }
                          }  // container out-drop-underrun

                          container out-drop-abort {
                            description
                              "OUT DROP ABORT";
                            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";
                            }
                          }  // container out-drop-abort

                          container out-drop-other {
                            description
                              "OUT DROP OTHER";
                            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";
                            }
                          }  // container out-drop-other

                          container out-error-other {
                            description
                              "OUT ERROR OTHER";
                            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";
                            }
                          }  // container out-error-other

                          container in-error-giant {
                            description
                              "IN ERROR GIANT";
                            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";
                            }
                          }  // container in-error-giant

                          container in-error-runt {
                            description
                              "IN ERROR RUNT";
                            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";
                            }
                          }  // container in-error-runt

                          container in-error-jabbers {
                            description
                              "IN ERROR JABBERS";
                            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";
                            }
                          }  // container in-error-jabbers

                          container in-error-fragments {
                            description
                              "IN ERROR FRAGMENTS";
                            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";
                            }
                          }  // container in-error-fragments

                          container in-error-other {
                            description
                              "IN ERROR OTHER";
                            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";
                            }
                          }  // container in-error-other

                          container in-pkt64-octet {
                            description
                              "IN PKT 64 OCTET";
                            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";
                            }
                          }  // container in-pkt64-octet

                          container in-pkts65-to127-octets {
                            description
                              "IN PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container in-pkts65-to127-octets

                          container in-pkts128-to255-octets {
                            description
                              "IN PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container in-pkts128-to255-octets

                          container in-pkts256-to511-octets {
                            description
                              "IN PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container in-pkts256-to511-octets

                          container in-pkts512-to1023-octets {
                            description
                              "IN PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container in-pkts512-to1023-octets

                          container in-pkts1024-to1518-octets {
                            description
                              "IN PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container in-pkts1024-to1518-octets

                          container outpkt64octet {
                            description
                              "OUT PKT 64 OCTET";
                            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";
                            }
                          }  // container outpkt64octet

                          container out-pkts65127-octets {
                            description
                              "OUT PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container out-pkts65127-octets

                          container out-pkts128255-octets {
                            description
                              "OUT PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container out-pkts128255-octets

                          container out-pkts256511-octets {
                            description
                              "OUT PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container out-pkts256511-octets

                          container out-pkts5121023-octets {
                            description
                              "OUT PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container out-pkts5121023-octets

                          container out-pkts10241518-octets {
                            description
                              "OUT PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container out-pkts10241518-octets

                          container rx-util {
                            description
                              "Rx Utilization in Percent";
                            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";
                            }
                          }  // container rx-util

                          container tx-util {
                            description
                              "Tx Utilization in Percent";
                            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";
                            }
                          }  // container tx-util

                          container tx-undersized-pkt {
                            description
                              "TX Undersized Pkt";
                            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";
                            }
                          }  // container tx-undersized-pkt

                          container tx-oversized-pkt {
                            description
                              "TX Oversized Pkt";
                            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";
                            }
                          }  // container tx-oversized-pkt

                          container tx-fragments {
                            description
                              "TX Fragments";
                            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";
                            }
                          }  // container tx-fragments

                          container tx-jabber {
                            description
                              "TX Jabber";
                            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";
                            }
                          }  // container tx-jabber

                          container tx-bad-fcs {
                            description
                              "TX Bad Fcs";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-minute15-ether-time-line-instance
                      }  // container macsec-minute15-ether-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-minute15-ether-history
                  }  // container macsec-minute15-ether-histories

                  container macsec-minute15secytx-histories {
                    description
                      "port current performance data";
                    list macsec-minute15secytx-history {
                      key "number";
                      description
                        "port 15-minute secy_tx performance data";
                      container macsec-minute15secytx-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-minute15secytx-time-line-instance {
                          key "number";
                          description
                            "port 15-minute secy_tx performance data
                           by index";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container out-pkts-protected {
                            description
                              "Out Packets Protected";
                            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";
                            }
                          }  // container out-pkts-protected

                          container out-pkts-encrypted {
                            description
                              "Out Packets Encrypted";
                            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";
                            }
                          }  // container out-pkts-encrypted

                          container out-octets-protected {
                            description
                              "Out Octets Protected ";
                            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";
                            }
                          }  // container out-octets-protected

                          container out-octets-encrypted {
                            description
                              "Out Octets Encrypted";
                            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";
                            }
                          }  // container out-octets-encrypted

                          container out-pkts-too-long {
                            description
                              "Out Packets Too Long";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-minute15secytx-time-line-instance
                      }  // container macsec-minute15secytx-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-minute15secytx-history
                  }  // container macsec-minute15secytx-histories

                  container macsec-minute15secyif-histories {
                    description
                      "port current performance data";
                    list macsec-minute15secyif-history {
                      key "number";
                      description
                        "port 15-minute secy_if performance data";
                      container macsec-minute15secyif-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-minute15secyif-time-line-instance {
                          key "number";
                          description
                            "port 15-minute secy_if performance data
                           by index";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container in-pkts-untagged {
                            description
                              "In Packet Untagged";
                            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";
                            }
                          }  // container in-pkts-untagged

                          container in-pkts-no-tag {
                            description
                              "In Packet No tag";
                            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";
                            }
                          }  // container in-pkts-no-tag

                          container in-pkts-bad-tag {
                            description
                              "In Packet Bad tag";
                            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";
                            }
                          }  // container in-pkts-bad-tag

                          container in-pkts-unknown-sci {
                            description
                              "In Packet Unknown sci";
                            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";
                            }
                          }  // container in-pkts-unknown-sci

                          container in-pkts-no-sci {
                            description
                              "In Packet No sci";
                            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";
                            }
                          }  // container in-pkts-no-sci

                          container in-pkts-overrun {
                            description
                              "In Packet Overrun";
                            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";
                            }
                          }  // container in-pkts-overrun

                          container in-octets-validated {
                            description
                              "In Octet Validated";
                            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";
                            }
                          }  // container in-octets-validated

                          container in-octets-decrypted {
                            description
                              "In Octet Decrypted";
                            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";
                            }
                          }  // container in-octets-decrypted

                          container out-pkts-untagged {
                            description
                              "Out Packet Untagged";
                            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";
                            }
                          }  // container out-pkts-untagged

                          container out-pkts-too-long {
                            description
                              "Out Packet Too Long";
                            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";
                            }
                          }  // container out-pkts-too-long

                          container out-octets-protected {
                            description
                              "Out Octet Protected";
                            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";
                            }
                          }  // container out-octets-protected

                          container out-octets-encrypted {
                            description
                              "Out Octet encrypted";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-minute15secyif-time-line-instance
                      }  // container macsec-minute15secyif-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-minute15secyif-history
                  }  // container macsec-minute15secyif-histories
                }  // container macsec-minute15-history

                container macsec-hour24-history {
                  description
                    "port current performance data";
                  container macsec-hour24-ether-histories {
                    description
                      "port current performance data";
                    list macsec-hour24-ether-history {
                      key "number";
                      description
                        "port 24 hour ether performance data";
                      container macsec-hour24-ether-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-hour24-ether-time-line-instance {
                          key "number";
                          description
                            "port 24 hour ether performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container rx-pkt {
                            description
                              "RX PKT";
                            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";
                            }
                          }  // container rx-pkt

                          container stat-pkt {
                            description
                              "STAT PKT";
                            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";
                            }
                          }  // container stat-pkt

                          container octet-stat {
                            description
                              "OCTET STAT";
                            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";
                            }
                          }  // container octet-stat

                          container oversize-pkt-stat {
                            description
                              "OVERSIZE PKT";
                            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";
                            }
                          }  // container oversize-pkt-stat

                          container fcs-errors-stat {
                            description
                              "FCS ERR";
                            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";
                            }
                          }  // container fcs-errors-stat

                          container long-frames-stat {
                            description
                              "LONG FRAMES";
                            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";
                            }
                          }  // container long-frames-stat

                          container jabber-stat {
                            description
                              "JABBER STATS";
                            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";
                            }
                          }  // container jabber-stat

                          container ether64-octets {
                            description
                              "SIXTY FOUR OCTET";
                            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";
                            }
                          }  // container ether64-octets

                          container ether65127-octet {
                            description
                              "OCTET";
                            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";
                            }
                          }  // container ether65127-octet

                          container ether128255-octet {
                            description
                              "TFF OCTET";
                            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";
                            }
                          }  // container ether128255-octet

                          container ether256511-octet {
                            description
                              "FOO OCTET";
                            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";
                            }
                          }  // container ether256511-octet

                          container ether5121023-octet {
                            description
                              "OZTT OCTET";
                            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";
                            }
                          }  // container ether5121023-octet

                          container ether10241518-octet {
                            description
                              "OFO OCTET";
                            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";
                            }
                          }  // container ether10241518-octet

                          container in-ucast-pkt {
                            description
                              "IN UCAST";
                            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";
                            }
                          }  // container in-ucast-pkt

                          container in-mcast-pkt {
                            description
                              "IN MCAST";
                            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";
                            }
                          }  // container in-mcast-pkt

                          container in-bcast-pkt {
                            description
                              "IN BCAST";
                            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";
                            }
                          }  // container in-bcast-pkt

                          container out-ucast-pkt {
                            description
                              "OUT UCAST";
                            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";
                            }
                          }  // container out-ucast-pkt

                          container out-bcast-pkt {
                            description
                              "OUT BCAST";
                            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";
                            }
                          }  // container out-bcast-pkt

                          container out-mcast-pkt {
                            description
                              "OUT MCAST";
                            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";
                            }
                          }  // container out-mcast-pkt

                          container tx-pkt {
                            description
                              "TX PKT";
                            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";
                            }
                          }  // container tx-pkt

                          container if-in-errors {
                            description
                              "IFIN ERRORS";
                            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";
                            }
                          }  // container if-in-errors

                          container if-in-octets {
                            description
                              "IFIN OCTETS";
                            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";
                            }
                          }  // container if-in-octets

                          container ether-stat-multicast-pkt {
                            description
                              "ETHER STAT MULTICAST PKT";
                            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";
                            }
                          }  // container ether-stat-multicast-pkt

                          container ether-stat-broadcast-pkt {
                            description
                              "ETHER STAT BROADCAST PKT";
                            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";
                            }
                          }  // container ether-stat-broadcast-pkt

                          container ether-stat-undersized-pkt {
                            description
                              "ETHER STAT UNDERSIZED PKT";
                            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";
                            }
                          }  // container ether-stat-undersized-pkt

                          container out-octets {
                            description
                              "OUT OCTET";
                            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";
                            }
                          }  // container out-octets

                          container in-pause-frame {
                            description
                              "INPUT PAUSE FRAME";
                            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";
                            }
                          }  // container in-pause-frame

                          container in-good-bytes {
                            description
                              "INPUT GOOD BYTES";
                            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";
                            }
                          }  // container in-good-bytes

                          container in8021q-frames {
                            description
                              "INPUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container in8021q-frames

                          container in-pkts1519-max-octets {
                            description
                              "INPUT PKTS 1519MAX OCTETS";
                            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";
                            }
                          }  // container in-pkts1519-max-octets

                          container in-good-pkts {
                            description
                              "INPUT GOOD PKTS";
                            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";
                            }
                          }  // container in-good-pkts

                          container in-drop-overrun {
                            description
                              "INPUT DROP OVERRUN";
                            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";
                            }
                          }  // container in-drop-overrun

                          container in-drop-abort {
                            description
                              "INPUT DROP ABORT";
                            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";
                            }
                          }  // container in-drop-abort

                          container in-drop-invalid-vlan {
                            description
                              "INPUT DROP INVALID VLAN";
                            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";
                            }
                          }  // container in-drop-invalid-vlan

                          container in-drop-invalid-dmac {
                            description
                              "INPUT DROP INVALID DMAC";
                            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";
                            }
                          }  // container in-drop-invalid-dmac

                          container in-drop-invalid-encap {
                            description
                              "INPUT DROP INVALID ENCAP";
                            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";
                            }
                          }  // container in-drop-invalid-encap

                          container in-drop-other {
                            description
                              "INPUT DROP OTHER";
                            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";
                            }
                          }  // container in-drop-other

                          container in-mib-giant {
                            description
                              "INPUT MIB GIANT";
                            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";
                            }
                          }  // container in-mib-giant

                          container in-mib-jabber {
                            description
                              "INPUT MIB JABBER";
                            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";
                            }
                          }  // container in-mib-jabber

                          container in-mibcrc {
                            description
                              "IN MIB CRC";
                            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";
                            }
                          }  // container in-mibcrc

                          container in-error-collisions {
                            description
                              "IN ERROR COLLISIONS";
                            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";
                            }
                          }  // container in-error-collisions

                          container in-error-symbol {
                            description
                              "IN ERROR SYMBOL";
                            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";
                            }
                          }  // container in-error-symbol

                          container out-good-bytes {
                            description
                              "OUT GOOD BYTES";
                            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";
                            }
                          }  // container out-good-bytes

                          container out8021q-frames {
                            description
                              "OUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container out8021q-frames

                          container out-pause-frames {
                            description
                              "OUT PAUSE FRAMES";
                            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";
                            }
                          }  // container out-pause-frames

                          container out-pkts1519-max-octets {
                            description
                              "OUT PKTS 1519 MAX OCTETS";
                            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";
                            }
                          }  // container out-pkts1519-max-octets

                          container out-good-pkts {
                            description
                              "OUT GOOD PKTS";
                            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";
                            }
                          }  // container out-good-pkts

                          container out-drop-underrun {
                            description
                              "OUT DROP UNDERRUN";
                            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";
                            }
                          }  // container out-drop-underrun

                          container out-drop-abort {
                            description
                              "OUT DROP ABORT";
                            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";
                            }
                          }  // container out-drop-abort

                          container out-drop-other {
                            description
                              "OUT DROP OTHER";
                            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";
                            }
                          }  // container out-drop-other

                          container out-error-other {
                            description
                              "OUT ERROR OTHER";
                            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";
                            }
                          }  // container out-error-other

                          container in-error-giant {
                            description
                              "IN ERROR GIANT";
                            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";
                            }
                          }  // container in-error-giant

                          container in-error-runt {
                            description
                              "IN ERROR RUNT";
                            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";
                            }
                          }  // container in-error-runt

                          container in-error-jabbers {
                            description
                              "IN ERROR JABBERS";
                            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";
                            }
                          }  // container in-error-jabbers

                          container in-error-fragments {
                            description
                              "IN ERROR FRAGMENTS";
                            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";
                            }
                          }  // container in-error-fragments

                          container in-error-other {
                            description
                              "IN ERROR OTHER";
                            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";
                            }
                          }  // container in-error-other

                          container in-pkt64-octet {
                            description
                              "IN PKT 64 OCTET";
                            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";
                            }
                          }  // container in-pkt64-octet

                          container in-pkts65-to127-octets {
                            description
                              "IN PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container in-pkts65-to127-octets

                          container in-pkts128-to255-octets {
                            description
                              "IN PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container in-pkts128-to255-octets

                          container in-pkts256-to511-octets {
                            description
                              "IN PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container in-pkts256-to511-octets

                          container in-pkts512-to1023-octets {
                            description
                              "IN PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container in-pkts512-to1023-octets

                          container in-pkts1024-to1518-octets {
                            description
                              "IN PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container in-pkts1024-to1518-octets

                          container outpkt64octet {
                            description
                              "OUT PKT 64 OCTET";
                            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";
                            }
                          }  // container outpkt64octet

                          container out-pkts65127-octets {
                            description
                              "OUT PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container out-pkts65127-octets

                          container out-pkts128255-octets {
                            description
                              "OUT PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container out-pkts128255-octets

                          container out-pkts256511-octets {
                            description
                              "OUT PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container out-pkts256511-octets

                          container out-pkts5121023-octets {
                            description
                              "OUT PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container out-pkts5121023-octets

                          container out-pkts10241518-octets {
                            description
                              "OUT PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container out-pkts10241518-octets

                          container rx-util {
                            description
                              "Rx Utilization in Percent";
                            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";
                            }
                          }  // container rx-util

                          container tx-util {
                            description
                              "Tx Utilization in Percent";
                            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";
                            }
                          }  // container tx-util

                          container tx-undersized-pkt {
                            description
                              "TX Undersized Pkt";
                            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";
                            }
                          }  // container tx-undersized-pkt

                          container tx-oversized-pkt {
                            description
                              "TX Oversized Pkt";
                            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";
                            }
                          }  // container tx-oversized-pkt

                          container tx-fragments {
                            description
                              "TX Fragments";
                            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";
                            }
                          }  // container tx-fragments

                          container tx-jabber {
                            description
                              "TX Jabber";
                            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";
                            }
                          }  // container tx-jabber

                          container tx-bad-fcs {
                            description
                              "TX Bad Fcs";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-hour24-ether-time-line-instance
                      }  // container macsec-hour24-ether-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-hour24-ether-history
                  }  // container macsec-hour24-ether-histories

                  container macsec-hour24secytx-histories {
                    description
                      "port current performance data";
                    list macsec-hour24secytx-history {
                      key "number";
                      description
                        "port 24 hour secy_tx performance data";
                      container macsec-hour24secytx-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-hour24secytx-time-line-instance {
                          key "number";
                          description
                            "port 24 hour secy_tx performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container out-pkts-protected {
                            description
                              "Out Packets Protected";
                            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";
                            }
                          }  // container out-pkts-protected

                          container out-pkts-encrypted {
                            description
                              "Out Packets Encrypted";
                            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";
                            }
                          }  // container out-pkts-encrypted

                          container out-octets-protected {
                            description
                              "Out Octets Protected ";
                            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";
                            }
                          }  // container out-octets-protected

                          container out-octets-encrypted {
                            description
                              "Out Octets Encrypted";
                            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";
                            }
                          }  // container out-octets-encrypted

                          container out-pkts-too-long {
                            description
                              "Out Packets Too Long";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-hour24secytx-time-line-instance
                      }  // container macsec-hour24secytx-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-hour24secytx-history
                  }  // container macsec-hour24secytx-histories

                  container macsec-hour24secyif-histories {
                    description
                      "port current performance data";
                    list macsec-hour24secyif-history {
                      key "number";
                      description
                        "port 24 hour secy_if performance data";
                      container macsec-hour24secyif-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-hour24secyif-time-line-instance {
                          key "number";
                          description
                            "port 24 hour secy_if performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container in-pkts-untagged {
                            description
                              "In Packet Untagged";
                            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";
                            }
                          }  // container in-pkts-untagged

                          container in-pkts-no-tag {
                            description
                              "In Packet No tag";
                            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";
                            }
                          }  // container in-pkts-no-tag

                          container in-pkts-bad-tag {
                            description
                              "In Packet Bad tag";
                            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";
                            }
                          }  // container in-pkts-bad-tag

                          container in-pkts-unknown-sci {
                            description
                              "In Packet Unknown sci";
                            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";
                            }
                          }  // container in-pkts-unknown-sci

                          container in-pkts-no-sci {
                            description
                              "In Packet No sci";
                            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";
                            }
                          }  // container in-pkts-no-sci

                          container in-pkts-overrun {
                            description
                              "In Packet Overrun";
                            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";
                            }
                          }  // container in-pkts-overrun

                          container in-octets-validated {
                            description
                              "In Octet Validated";
                            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";
                            }
                          }  // container in-octets-validated

                          container in-octets-decrypted {
                            description
                              "In Octet Decrypted";
                            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";
                            }
                          }  // container in-octets-decrypted

                          container out-pkts-untagged {
                            description
                              "Out Packet Untagged";
                            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";
                            }
                          }  // container out-pkts-untagged

                          container out-pkts-too-long {
                            description
                              "Out Packet Too Long";
                            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";
                            }
                          }  // container out-pkts-too-long

                          container out-octets-protected {
                            description
                              "Out Octet Protected";
                            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";
                            }
                          }  // container out-octets-protected

                          container out-octets-encrypted {
                            description
                              "Out Octet encrypted";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-hour24secyif-time-line-instance
                      }  // container macsec-hour24secyif-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-hour24secyif-history
                  }  // container macsec-hour24secyif-histories

                  container macsec-hour24secyrx-histories {
                    description
                      "port current performance data";
                    list macsec-hour24secyrx-history {
                      key "number";
                      description
                        "port 24 hour secy_rx performance data";
                      container macsec-hour24secyrx-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-hour24secyrx-time-line-instance {
                          key "number";
                          description
                            "port 24 hour secy_rx performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container in-pkts-unchecked {
                            description
                              "In Packet Unchecked";
                            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";
                            }
                          }  // container in-pkts-unchecked

                          container in-pkts-delayed {
                            description
                              "In Packet Delay";
                            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";
                            }
                          }  // container in-pkts-delayed

                          container in-pkts-late {
                            description
                              "In Packet Late";
                            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";
                            }
                          }  // container in-pkts-late

                          container in-pkts-ok {
                            description
                              "In Packet Ok";
                            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";
                            }
                          }  // container in-pkts-ok

                          container in-pkts-invalid {
                            description
                              "In Packet Invalid";
                            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";
                            }
                          }  // container in-pkts-invalid

                          container in-pkts-not-valid {
                            description
                              "In Packet Not Valid";
                            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";
                            }
                          }  // container in-pkts-not-valid

                          container in-pkts-not-using-sa {
                            description
                              "In Packet Not Using SA";
                            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";
                            }
                          }  // container in-pkts-not-using-sa

                          container in-pkts-unused-sa {
                            description
                              "In Packet Unused SA";
                            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";
                            }
                          }  // container in-pkts-unused-sa

                          container in-pkts-untagged-hit {
                            description
                              "In Packet Untagged Hit";
                            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";
                            }
                          }  // container in-pkts-untagged-hit

                          container in-octets-validated {
                            description
                              "In Octet Validated";
                            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";
                            }
                          }  // container in-octets-validated

                          container in-octets-decrypted {
                            description
                              "In Octet Decrypted";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-hour24secyrx-time-line-instance
                      }  // container macsec-hour24secyrx-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-hour24secyrx-history
                  }  // container macsec-hour24secyrx-histories
                }  // container macsec-hour24-history

                container macsec-second30-history {
                  description
                    "port current performance data";
                  container macsec-second30secyrx-histories {
                    description
                      "port current performance data";
                    list macsec-second30secyrx-history {
                      key "number";
                      description
                        "port 30-second secy_rx performance data";
                      container macsec-second30secyrx-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-second30secyrx-time-line-instance {
                          key "number";
                          description
                            "port 30-second secy_rx performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container in-pkts-unchecked {
                            description
                              "In Packet Unchecked";
                            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";
                            }
                          }  // container in-pkts-unchecked

                          container in-pkts-delayed {
                            description
                              "In Packet Delay";
                            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";
                            }
                          }  // container in-pkts-delayed

                          container in-pkts-late {
                            description
                              "In Packet Late";
                            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";
                            }
                          }  // container in-pkts-late

                          container in-pkts-ok {
                            description
                              "In Packet Ok";
                            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";
                            }
                          }  // container in-pkts-ok

                          container in-pkts-invalid {
                            description
                              "In Packet Invalid";
                            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";
                            }
                          }  // container in-pkts-invalid

                          container in-pkts-not-valid {
                            description
                              "In Packet Not Valid";
                            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";
                            }
                          }  // container in-pkts-not-valid

                          container in-pkts-not-using-sa {
                            description
                              "In Packet Not Using SA";
                            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";
                            }
                          }  // container in-pkts-not-using-sa

                          container in-pkts-unused-sa {
                            description
                              "In Packet Unused SA";
                            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";
                            }
                          }  // container in-pkts-unused-sa

                          container in-pkts-untagged-hit {
                            description
                              "In Packet Untagged Hit";
                            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";
                            }
                          }  // container in-pkts-untagged-hit

                          container in-octets-validated {
                            description
                              "In Octet Validated";
                            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";
                            }
                          }  // container in-octets-validated

                          container in-octets-decrypted {
                            description
                              "In Octet Decrypted";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-second30secyrx-time-line-instance
                      }  // container macsec-second30secyrx-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-second30secyrx-history
                  }  // container macsec-second30secyrx-histories

                  container macsec-second30-ether-histories {
                    description
                      "port current performance data";
                    list macsec-second30-ether-history {
                      key "number";
                      description
                        "port 30-second ether performance data";
                      container macsec-second30-ether-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-second30-ether-time-line-instance {
                          key "number";
                          description
                            "port 30-second ether performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container rx-pkt {
                            description
                              "RX PKT";
                            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";
                            }
                          }  // container rx-pkt

                          container stat-pkt {
                            description
                              "STAT PKT";
                            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";
                            }
                          }  // container stat-pkt

                          container octet-stat {
                            description
                              "OCTET STAT";
                            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";
                            }
                          }  // container octet-stat

                          container oversize-pkt-stat {
                            description
                              "OVERSIZE PKT";
                            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";
                            }
                          }  // container oversize-pkt-stat

                          container fcs-errors-stat {
                            description
                              "FCS ERR";
                            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";
                            }
                          }  // container fcs-errors-stat

                          container long-frames-stat {
                            description
                              "LONG FRAMES";
                            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";
                            }
                          }  // container long-frames-stat

                          container jabber-stat {
                            description
                              "JABBER STATS";
                            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";
                            }
                          }  // container jabber-stat

                          container ether64-octets {
                            description
                              "SIXTY FOUR OCTET";
                            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";
                            }
                          }  // container ether64-octets

                          container ether65127-octet {
                            description
                              "OCTET";
                            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";
                            }
                          }  // container ether65127-octet

                          container ether128255-octet {
                            description
                              "TFF OCTET";
                            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";
                            }
                          }  // container ether128255-octet

                          container ether256511-octet {
                            description
                              "FOO OCTET";
                            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";
                            }
                          }  // container ether256511-octet

                          container ether5121023-octet {
                            description
                              "OZTT OCTET";
                            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";
                            }
                          }  // container ether5121023-octet

                          container ether10241518-octet {
                            description
                              "OFO OCTET";
                            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";
                            }
                          }  // container ether10241518-octet

                          container in-ucast-pkt {
                            description
                              "IN UCAST";
                            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";
                            }
                          }  // container in-ucast-pkt

                          container in-mcast-pkt {
                            description
                              "IN MCAST";
                            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";
                            }
                          }  // container in-mcast-pkt

                          container in-bcast-pkt {
                            description
                              "IN BCAST";
                            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";
                            }
                          }  // container in-bcast-pkt

                          container out-ucast-pkt {
                            description
                              "OUT UCAST";
                            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";
                            }
                          }  // container out-ucast-pkt

                          container out-bcast-pkt {
                            description
                              "OUT BCAST";
                            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";
                            }
                          }  // container out-bcast-pkt

                          container out-mcast-pkt {
                            description
                              "OUT MCAST";
                            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";
                            }
                          }  // container out-mcast-pkt

                          container tx-pkt {
                            description
                              "TX PKT";
                            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";
                            }
                          }  // container tx-pkt

                          container if-in-errors {
                            description
                              "IFIN ERRORS";
                            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";
                            }
                          }  // container if-in-errors

                          container if-in-octets {
                            description
                              "IFIN OCTETS";
                            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";
                            }
                          }  // container if-in-octets

                          container ether-stat-multicast-pkt {
                            description
                              "ETHER STAT MULTICAST PKT";
                            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";
                            }
                          }  // container ether-stat-multicast-pkt

                          container ether-stat-broadcast-pkt {
                            description
                              "ETHER STAT BROADCAST PKT";
                            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";
                            }
                          }  // container ether-stat-broadcast-pkt

                          container ether-stat-undersized-pkt {
                            description
                              "ETHER STAT UNDERSIZED PKT";
                            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";
                            }
                          }  // container ether-stat-undersized-pkt

                          container out-octets {
                            description
                              "OUT OCTET";
                            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";
                            }
                          }  // container out-octets

                          container in-pause-frame {
                            description
                              "INPUT PAUSE FRAME";
                            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";
                            }
                          }  // container in-pause-frame

                          container in-good-bytes {
                            description
                              "INPUT GOOD BYTES";
                            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";
                            }
                          }  // container in-good-bytes

                          container in8021q-frames {
                            description
                              "INPUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container in8021q-frames

                          container in-pkts1519-max-octets {
                            description
                              "INPUT PKTS 1519MAX OCTETS";
                            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";
                            }
                          }  // container in-pkts1519-max-octets

                          container in-good-pkts {
                            description
                              "INPUT GOOD PKTS";
                            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";
                            }
                          }  // container in-good-pkts

                          container in-drop-overrun {
                            description
                              "INPUT DROP OVERRUN";
                            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";
                            }
                          }  // container in-drop-overrun

                          container in-drop-abort {
                            description
                              "INPUT DROP ABORT";
                            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";
                            }
                          }  // container in-drop-abort

                          container in-drop-invalid-vlan {
                            description
                              "INPUT DROP INVALID VLAN";
                            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";
                            }
                          }  // container in-drop-invalid-vlan

                          container in-drop-invalid-dmac {
                            description
                              "INPUT DROP INVALID DMAC";
                            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";
                            }
                          }  // container in-drop-invalid-dmac

                          container in-drop-invalid-encap {
                            description
                              "INPUT DROP INVALID ENCAP";
                            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";
                            }
                          }  // container in-drop-invalid-encap

                          container in-drop-other {
                            description
                              "INPUT DROP OTHER";
                            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";
                            }
                          }  // container in-drop-other

                          container in-mib-giant {
                            description
                              "INPUT MIB GIANT";
                            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";
                            }
                          }  // container in-mib-giant

                          container in-mib-jabber {
                            description
                              "INPUT MIB JABBER";
                            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";
                            }
                          }  // container in-mib-jabber

                          container in-mibcrc {
                            description
                              "IN MIB CRC";
                            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";
                            }
                          }  // container in-mibcrc

                          container in-error-collisions {
                            description
                              "IN ERROR COLLISIONS";
                            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";
                            }
                          }  // container in-error-collisions

                          container in-error-symbol {
                            description
                              "IN ERROR SYMBOL";
                            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";
                            }
                          }  // container in-error-symbol

                          container out-good-bytes {
                            description
                              "OUT GOOD BYTES";
                            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";
                            }
                          }  // container out-good-bytes

                          container out8021q-frames {
                            description
                              "OUT 802 1Q FRAMES";
                            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";
                            }
                          }  // container out8021q-frames

                          container out-pause-frames {
                            description
                              "OUT PAUSE FRAMES";
                            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";
                            }
                          }  // container out-pause-frames

                          container out-pkts1519-max-octets {
                            description
                              "OUT PKTS 1519 MAX OCTETS";
                            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";
                            }
                          }  // container out-pkts1519-max-octets

                          container out-good-pkts {
                            description
                              "OUT GOOD PKTS";
                            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";
                            }
                          }  // container out-good-pkts

                          container out-drop-underrun {
                            description
                              "OUT DROP UNDERRUN";
                            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";
                            }
                          }  // container out-drop-underrun

                          container out-drop-abort {
                            description
                              "OUT DROP ABORT";
                            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";
                            }
                          }  // container out-drop-abort

                          container out-drop-other {
                            description
                              "OUT DROP OTHER";
                            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";
                            }
                          }  // container out-drop-other

                          container out-error-other {
                            description
                              "OUT ERROR OTHER";
                            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";
                            }
                          }  // container out-error-other

                          container in-error-giant {
                            description
                              "IN ERROR GIANT";
                            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";
                            }
                          }  // container in-error-giant

                          container in-error-runt {
                            description
                              "IN ERROR RUNT";
                            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";
                            }
                          }  // container in-error-runt

                          container in-error-jabbers {
                            description
                              "IN ERROR JABBERS";
                            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";
                            }
                          }  // container in-error-jabbers

                          container in-error-fragments {
                            description
                              "IN ERROR FRAGMENTS";
                            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";
                            }
                          }  // container in-error-fragments

                          container in-error-other {
                            description
                              "IN ERROR OTHER";
                            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";
                            }
                          }  // container in-error-other

                          container in-pkt64-octet {
                            description
                              "IN PKT 64 OCTET";
                            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";
                            }
                          }  // container in-pkt64-octet

                          container in-pkts65-to127-octets {
                            description
                              "IN PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container in-pkts65-to127-octets

                          container in-pkts128-to255-octets {
                            description
                              "IN PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container in-pkts128-to255-octets

                          container in-pkts256-to511-octets {
                            description
                              "IN PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container in-pkts256-to511-octets

                          container in-pkts512-to1023-octets {
                            description
                              "IN PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container in-pkts512-to1023-octets

                          container in-pkts1024-to1518-octets {
                            description
                              "IN PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container in-pkts1024-to1518-octets

                          container outpkt64octet {
                            description
                              "OUT PKT 64 OCTET";
                            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";
                            }
                          }  // container outpkt64octet

                          container out-pkts65127-octets {
                            description
                              "OUT PKTS 65 127OCTETS";
                            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";
                            }
                          }  // container out-pkts65127-octets

                          container out-pkts128255-octets {
                            description
                              "OUT PKTS 128 255 OCTETS";
                            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";
                            }
                          }  // container out-pkts128255-octets

                          container out-pkts256511-octets {
                            description
                              "OUT PKTS 256 511 OCTETS";
                            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";
                            }
                          }  // container out-pkts256511-octets

                          container out-pkts5121023-octets {
                            description
                              "OUT PKTS 512 1023 OCTETS";
                            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";
                            }
                          }  // container out-pkts5121023-octets

                          container out-pkts10241518-octets {
                            description
                              "OUT PKTS 1024 1518 OCTETS";
                            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";
                            }
                          }  // container out-pkts10241518-octets

                          container rx-util {
                            description
                              "Rx Utilization in Percent";
                            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";
                            }
                          }  // container rx-util

                          container tx-util {
                            description
                              "Tx Utilization in Percent";
                            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";
                            }
                          }  // container tx-util

                          container tx-undersized-pkt {
                            description
                              "TX Undersized Pkt";
                            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";
                            }
                          }  // container tx-undersized-pkt

                          container tx-oversized-pkt {
                            description
                              "TX Oversized Pkt";
                            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";
                            }
                          }  // container tx-oversized-pkt

                          container tx-fragments {
                            description
                              "TX Fragments";
                            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";
                            }
                          }  // container tx-fragments

                          container tx-jabber {
                            description
                              "TX Jabber";
                            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";
                            }
                          }  // container tx-jabber

                          container tx-bad-fcs {
                            description
                              "TX Bad Fcs";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-second30-ether-time-line-instance
                      }  // container macsec-second30-ether-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-second30-ether-history
                  }  // container macsec-second30-ether-histories

                  container macsec-second30secytx-histories {
                    description
                      "port current performance data";
                    list macsec-second30secytx-history {
                      key "number";
                      description
                        "port 30-second secy_tx performance data";
                      container macsec-second30secytx-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-second30secytx-time-line-instance {
                          key "number";
                          description
                            "port 30-second secy_tx performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container out-pkts-protected {
                            description
                              "Out Packets Protected";
                            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";
                            }
                          }  // container out-pkts-protected

                          container out-pkts-encrypted {
                            description
                              "Out Packets Encrypted";
                            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";
                            }
                          }  // container out-pkts-encrypted

                          container out-octets-protected {
                            description
                              "Out Octets Protected ";
                            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";
                            }
                          }  // container out-octets-protected

                          container out-octets-encrypted {
                            description
                              "Out Octets Encrypted";
                            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";
                            }
                          }  // container out-octets-encrypted

                          container out-pkts-too-long {
                            description
                              "Out Packets Too Long";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-second30secytx-time-line-instance
                      }  // container macsec-second30secytx-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-second30secytx-history
                  }  // container macsec-second30secytx-histories

                  container macsec-second30secyif-histories {
                    description
                      "port current performance data";
                    list macsec-second30secyif-history {
                      key "number";
                      description
                        "port 30-second secy_if performance data";
                      container macsec-second30secyif-time-line-instances {
                        description
                          "port current performance data";
                        list macsec-second30secyif-time-line-instance {
                          key "number";
                          description
                            "port 30-second secy_if performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container in-pkts-untagged {
                            description
                              "In Packet Untagged";
                            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";
                            }
                          }  // container in-pkts-untagged

                          container in-pkts-no-tag {
                            description
                              "In Packet No tag";
                            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";
                            }
                          }  // container in-pkts-no-tag

                          container in-pkts-bad-tag {
                            description
                              "In Packet Bad tag";
                            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";
                            }
                          }  // container in-pkts-bad-tag

                          container in-pkts-unknown-sci {
                            description
                              "In Packet Unknown sci";
                            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";
                            }
                          }  // container in-pkts-unknown-sci

                          container in-pkts-no-sci {
                            description
                              "In Packet No sci";
                            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";
                            }
                          }  // container in-pkts-no-sci

                          container in-pkts-overrun {
                            description
                              "In Packet Overrun";
                            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";
                            }
                          }  // container in-pkts-overrun

                          container in-octets-validated {
                            description
                              "In Octet Validated";
                            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";
                            }
                          }  // container in-octets-validated

                          container in-octets-decrypted {
                            description
                              "In Octet Decrypted";
                            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";
                            }
                          }  // container in-octets-decrypted

                          container out-pkts-untagged {
                            description
                              "Out Packet Untagged";
                            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";
                            }
                          }  // container out-pkts-untagged

                          container out-pkts-too-long {
                            description
                              "Out Packet Too Long";
                            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";
                            }
                          }  // container out-pkts-too-long

                          container out-octets-protected {
                            description
                              "Out Octet Protected";
                            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";
                            }
                          }  // container out-octets-protected

                          container out-octets-encrypted {
                            description
                              "Out Octet encrypted";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list macsec-second30secyif-time-line-instance
                      }  // container macsec-second30secyif-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list macsec-second30secyif-history
                  }  // container macsec-second30secyif-histories
                }  // container macsec-second30-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list macsec-port-history
            }  // container macsec-port-histories
          }  // container macsec-history

          container odu-history {
            description
              "ODU controller History performance data";
            container odu-port-histories {
              description
                "Port performance data";
              list odu-port-history {
                key "name";
                description
                  "Port performance data";
                container odu-hour24-history {
                  description
                    "port current performance data";
                  container odu-hour24gfp-histories {
                    description
                      "port 24 hour performance data";
                    list odu-hour24gfp-history {
                      key "number";
                      description
                        "port 24 hour otn performance data";
                      container odu-hour24gfp-time-line-instances {
                        description
                          "port current performance data";
                        list odu-hour24gfp-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container rx-bit-err {
                            description
                              "RX BIT ERR";
                            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";
                            }
                          }  // container rx-bit-err

                          container rx-inv-typ {
                            description
                              "RX INV TYP";
                            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";
                            }
                          }  // container rx-inv-typ

                          container rx-crc {
                            description
                              "RX CRC";
                            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";
                            }
                          }  // container rx-crc

                          container rx-lfd {
                            description
                              "RX LFD";
                            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";
                            }
                          }  // container rx-lfd

                          container rx-csf {
                            description
                              "RX CSF";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list odu-hour24gfp-time-line-instance
                      }  // container odu-hour24gfp-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list odu-hour24gfp-history
                  }  // container odu-hour24gfp-histories

                  container odu-hour24prbs-histories {
                    description
                      "port 24 hour performance data";
                    list odu-hour24prbs-history {
                      key "number";
                      description
                        "port 24 hour prbs performance data";
                      container odu-hour24prbs-time-line-instances {
                        description
                          "port current performance data";
                        list odu-hour24prbs-time-line-instance {
                          key "number";
                          description
                            "port 15-minute prbs performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container ebc-tca {
                            description
                              "EBC TCA";
                            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";
                            }
                          }  // container ebc-tca

                          container found-count-tca {
                            description
                              "FOUND COUNT TCA";
                            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";
                            }
                          }  // container found-count-tca

                          container lost-count-tca {
                            description
                              "LOST COUNT TCA";
                            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";
                            }
                          }  // container lost-count-tca

                          container rcv-patt {
                            description
                              "RCVD PTRN";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf rcv-patt {
                              type Pm-prbs-pattern-et;
                              description
                                "RCVD PTRN";
                            }
                          }  // container rcv-patt

                          container prbs-status {
                            description
                              "PRBS STATUS";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf prbs-status {
                              type Pm-prbs-status-et;
                              description
                                "Prbs Status";
                            }
                          }  // 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";
                          }
                        }  // list odu-hour24prbs-time-line-instance
                      }  // container odu-hour24prbs-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list odu-hour24prbs-history
                  }  // container odu-hour24prbs-histories

                  container odu-hour24otn-histories {
                    description
                      "port 24 hour performance data";
                    list odu-hour24otn-history {
                      key "number";
                      description
                        "port 24 hour otn performance data";
                      container odu-hour24otn-time-line-instances {
                        description
                          "port current performance data";
                        list odu-hour24otn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list odu-hour24otn-time-line-instance
                      }  // container odu-hour24otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list odu-hour24otn-history
                  }  // container odu-hour24otn-histories
                }  // container odu-hour24-history

                container odu-minute15-history {
                  description
                    "port current performance data";
                  container odu-minute15prbs-histories {
                    description
                      "port current performance data";
                    list odu-minute15prbs-history {
                      key "number";
                      description
                        "port 15-minute prbs performance data";
                      container odu-minute15prbs-time-line-instances {
                        description
                          "port current performance data";
                        list odu-minute15prbs-time-line-instance {
                          key "number";
                          description
                            "port 15-minute prbs performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container ebc-tca {
                            description
                              "EBC TCA";
                            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";
                            }
                          }  // container ebc-tca

                          container found-count-tca {
                            description
                              "FOUND COUNT TCA";
                            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";
                            }
                          }  // container found-count-tca

                          container lost-count-tca {
                            description
                              "LOST COUNT TCA";
                            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";
                            }
                          }  // container lost-count-tca

                          container rcv-patt {
                            description
                              "RCVD PTRN";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf rcv-patt {
                              type Pm-prbs-pattern-et;
                              description
                                "RCVD PTRN";
                            }
                          }  // container rcv-patt

                          container prbs-status {
                            description
                              "PRBS STATUS";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf prbs-status {
                              type Pm-prbs-status-et;
                              description
                                "Prbs Status";
                            }
                          }  // 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";
                          }
                        }  // list odu-minute15prbs-time-line-instance
                      }  // container odu-minute15prbs-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list odu-minute15prbs-history
                  }  // container odu-minute15prbs-histories

                  container odu-minute15gfp-histories {
                    description
                      "port current performance data";
                    list odu-minute15gfp-history {
                      key "number";
                      description
                        "port 15-minute otn performance data";
                      container odu-minute15gfp-time-line-instances {
                        description
                          "port current performance data";
                        list odu-minute15gfp-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container rx-bit-err {
                            description
                              "RX BIT ERR";
                            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";
                            }
                          }  // container rx-bit-err

                          container rx-inv-typ {
                            description
                              "RX INV TYP";
                            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";
                            }
                          }  // container rx-inv-typ

                          container rx-crc {
                            description
                              "RX CRC";
                            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";
                            }
                          }  // container rx-crc

                          container rx-lfd {
                            description
                              "RX LFD";
                            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";
                            }
                          }  // container rx-lfd

                          container rx-csf {
                            description
                              "RX CSF";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list odu-minute15gfp-time-line-instance
                      }  // container odu-minute15gfp-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list odu-minute15gfp-history
                  }  // container odu-minute15gfp-histories

                  container odu-minute15otn-histories {
                    description
                      "port current performance data";
                    list odu-minute15otn-history {
                      key "number";
                      description
                        "port 15-minute otn performance data";
                      container odu-minute15otn-time-line-instances {
                        description
                          "port current performance data";
                        list odu-minute15otn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list odu-minute15otn-time-line-instance
                      }  // container odu-minute15otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list odu-minute15otn-history
                  }  // container odu-minute15otn-histories
                }  // container odu-minute15-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list odu-port-history
            }  // container odu-port-histories
          }  // container odu-history

          container otu-history {
            description
              "OTU controller History performance data";
            container otu-port-histories {
              description
                "Port performance data";
              list otu-port-history {
                key "name";
                description
                  "Port performance data";
                container otu-second30-history {
                  description
                    "port current performance data";
                  container otu-second30fec-histories {
                    description
                      "port current performance data";
                    list otu-second30fec-history {
                      key "number";
                      description
                        "port 30-second fec performance data";
                      container otu-second30fec-time-line-instances {
                        description
                          "port current performance data";
                        list otu-second30fec-time-line-instance {
                          key "number";
                          description
                            "port 30-second fec performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list otu-second30fec-time-line-instance
                      }  // container otu-second30fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-second30fec-history
                  }  // container otu-second30fec-histories

                  container otu-second30prbs-histories {
                    description
                      "prbs 30-sec performance data";
                    list otu-second30prbs-history {
                      key "number";
                      description
                        "prbs 30-sec prbs performance data";
                      container otu-second30prbs-time-line-instances {
                        description
                          "prbs 30-sec current performance data";
                        list otu-second30prbs-time-line-instance {
                          key "number";
                          description
                            "prbs 30-sec prbs performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container ebc-tca {
                            description
                              "EBC TCA";
                            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";
                            }
                          }  // container ebc-tca

                          container found-count-tca {
                            description
                              "FOUND COUNT TCA";
                            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";
                            }
                          }  // container found-count-tca

                          container lost-count-tca {
                            description
                              "LOST COUNT TCA";
                            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";
                            }
                          }  // container lost-count-tca

                          container rcv-patt {
                            description
                              "RCVD PTRN";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf rcv-patt {
                              type Pm-prbs-pattern-et;
                              description
                                "RCVD PTRN";
                            }
                          }  // container rcv-patt

                          container prbs-status {
                            description
                              "PRBS STATUS";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf prbs-status {
                              type Pm-prbs-status-et;
                              description
                                "Prbs Status";
                            }
                          }  // 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";
                          }
                        }  // list otu-second30prbs-time-line-instance
                      }  // container otu-second30prbs-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-second30prbs-history
                  }  // container otu-second30prbs-histories

                  container otu-second30otn-histories {
                    description
                      "port current performance data";
                    list otu-second30otn-history {
                      key "number";
                      description
                        "port 30-second otn performance data";
                      container otu-second30otn-time-line-instances {
                        description
                          "port current performance data";
                        list otu-second30otn-time-line-instance {
                          key "number";
                          description
                            "port 30-second otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list otu-second30otn-time-line-instance
                      }  // container otu-second30otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-second30otn-history
                  }  // container otu-second30otn-histories
                }  // container otu-second30-history

                container otu-minute15-history {
                  description
                    "port current performance data";
                  container otu-minute15fec-histories {
                    description
                      "port current performance data";
                    list otu-minute15fec-history {
                      key "number";
                      description
                        "port 15-minute fec performance data";
                      container otu-minute15fec-time-line-instances {
                        description
                          "port current performance data";
                        list otu-minute15fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list otu-minute15fec-time-line-instance
                      }  // container otu-minute15fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-minute15fec-history
                  }  // container otu-minute15fec-histories

                  container otu-minute15prbs-histories {
                    description
                      "port current performance data";
                    list otu-minute15prbs-history {
                      key "number";
                      description
                        "port 15-minute prbs performance data";
                      container otu-minute15prbs-time-line-instances {
                        description
                          "port current performance data";
                        list otu-minute15prbs-time-line-instance {
                          key "number";
                          description
                            "port 15-minute prbs performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container ebc-tca {
                            description
                              "EBC TCA";
                            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";
                            }
                          }  // container ebc-tca

                          container found-count-tca {
                            description
                              "FOUND COUNT TCA";
                            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";
                            }
                          }  // container found-count-tca

                          container lost-count-tca {
                            description
                              "LOST COUNT TCA";
                            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";
                            }
                          }  // container lost-count-tca

                          container rcv-patt {
                            description
                              "RCVD PTRN";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf rcv-patt {
                              type Pm-prbs-pattern-et;
                              description
                                "RCVD PTRN";
                            }
                          }  // container rcv-patt

                          container prbs-status {
                            description
                              "PRBS STATUS";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf prbs-status {
                              type Pm-prbs-status-et;
                              description
                                "Prbs Status";
                            }
                          }  // 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";
                          }
                        }  // list otu-minute15prbs-time-line-instance
                      }  // container otu-minute15prbs-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-minute15prbs-history
                  }  // container otu-minute15prbs-histories

                  container otu-minute15otn-histories {
                    description
                      "port current performance data";
                    list otu-minute15otn-history {
                      key "number";
                      description
                        "port 15-minute otn performance data";
                      container otu-minute15otn-time-line-instances {
                        description
                          "port current performance data";
                        list otu-minute15otn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list otu-minute15otn-time-line-instance
                      }  // container otu-minute15otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-minute15otn-history
                  }  // container otu-minute15otn-histories
                }  // container otu-minute15-history

                container otu-hour24-history {
                  description
                    "port current performance data";
                  container otu-hour24prbs-histories {
                    description
                      "port 24 hour performance data";
                    list otu-hour24prbs-history {
                      key "number";
                      description
                        "port 24 hour prbs performance data";
                      container otu-hour24prbs-time-line-instances {
                        description
                          "port current performance data";
                        list otu-hour24prbs-time-line-instance {
                          key "number";
                          description
                            "port 15-minute prbs performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container ebc-tca {
                            description
                              "EBC TCA";
                            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";
                            }
                          }  // container ebc-tca

                          container found-count-tca {
                            description
                              "FOUND COUNT TCA";
                            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";
                            }
                          }  // container found-count-tca

                          container lost-count-tca {
                            description
                              "LOST COUNT TCA";
                            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";
                            }
                          }  // container lost-count-tca

                          container rcv-patt {
                            description
                              "RCVD PTRN";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf rcv-patt {
                              type Pm-prbs-pattern-et;
                              description
                                "RCVD PTRN";
                            }
                          }  // container rcv-patt

                          container prbs-status {
                            description
                              "PRBS STATUS";
                            leaf valid {
                              type boolean;
                              description
                                "valid";
                            }

                            leaf prbs-status {
                              type Pm-prbs-status-et;
                              description
                                "Prbs Status";
                            }
                          }  // 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";
                          }
                        }  // list otu-hour24prbs-time-line-instance
                      }  // container otu-hour24prbs-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-hour24prbs-history
                  }  // container otu-hour24prbs-histories

                  container otu-hour24otn-histories {
                    description
                      "port 24 hour performance data";
                    list otu-hour24otn-history {
                      key "number";
                      description
                        "port 24 hour otn performance data";
                      container otu-hour24otn-time-line-instances {
                        description
                          "port current performance data";
                        list otu-hour24otn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container es-ne {
                            description
                              "ES SM NE";
                            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";
                            }
                          }  // container es-ne

                          container esr-ne {
                            description
                              "ESR PM NE";
                            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";
                            }
                          }  // container esr-ne

                          container ses-ne {
                            description
                              "SES SM NE";
                            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";
                            }
                          }  // container ses-ne

                          container sesr-ne {
                            description
                              "SESR SM NE";
                            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";
                            }
                          }  // container sesr-ne

                          container uas-ne {
                            description
                              "UAS SM NE";
                            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";
                            }
                          }  // container uas-ne

                          container bbe-ne {
                            description
                              "BBE SM NE";
                            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";
                            }
                          }  // container bbe-ne

                          container bber-ne {
                            description
                              "BBER SM NE";
                            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";
                            }
                          }  // container bber-ne

                          container fc-ne {
                            description
                              "FC SM NE";
                            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";
                            }
                          }  // container fc-ne

                          container es-fe {
                            description
                              "ES SM FE";
                            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";
                            }
                          }  // container es-fe

                          container esr-fe {
                            description
                              "ESR PM FE";
                            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";
                            }
                          }  // container esr-fe

                          container ses-fe {
                            description
                              "SES SM FE";
                            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";
                            }
                          }  // container ses-fe

                          container sesr-fe {
                            description
                              "SESR SM FE";
                            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";
                            }
                          }  // container sesr-fe

                          container uas-fe {
                            description
                              "UAS SM FE";
                            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";
                            }
                          }  // container uas-fe

                          container bbe-fe {
                            description
                              "BBE SM FE";
                            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";
                            }
                          }  // container bbe-fe

                          container bber-fe {
                            description
                              "BBER SM FE";
                            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";
                            }
                          }  // container bber-fe

                          container fc-fe {
                            description
                              "FC SM FE";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list otu-hour24otn-time-line-instance
                      }  // container otu-hour24otn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-hour24otn-history
                  }  // container otu-hour24otn-histories

                  container otu-hour24fec-histories {
                    description
                      "port current performance data";
                    list otu-hour24fec-history {
                      key "number";
                      description
                        "port 24 hour fec performance data";
                      container otu-hour24fec-time-line-instances {
                        description
                          "port current performance data";
                        list otu-hour24fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list otu-hour24fec-time-line-instance
                      }  // container otu-hour24fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list otu-hour24fec-history
                  }  // container otu-hour24fec-histories
                }  // container otu-hour24-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list otu-port-history
            }  // container otu-port-histories
          }  // container otu-history

          container ho-vc-history {
            description
              "HO_VC controller History performance data";
            container ho-vc-port-histories {
              description
                "Port performance data";
              list ho-vc-port-history {
                key "name";
                description
                  "Port performance data";
                container ho-vc-minute15-history {
                  description
                    "port current performance data";
                  container ho-vc-minute15-path-histories {
                    description
                      "port current performance data";
                    list ho-vc-minute15-path-history {
                      key "number";
                      description
                        "port 15-minute Path performance data";
                      container ho-vc-minute15-path-time-line-instances {
                        description
                          "port current performance data";
                        list ho-vc-minute15-path-time-line-instance {
                          key "number";
                          description
                            "port 15-minute ho_vc performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container path {
                            description
                              "PATH";
                            container path-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-e-ss

                            container path-es-rs {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-es-rs

                            container path-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-se-ss

                            container path-ses-rs {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-ses-rs

                            container path-e-bs {
                              description
                                "The number of Errored blocks";
                              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";
                              }
                            }  // container path-e-bs

                            container path-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container path-ua-ss

                            container path-bb-es {
                              description
                                "The number of background block errors";
                              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";
                              }
                            }  // container path-bb-es

                            container path-bbe-rs {
                              description
                                "The number of background block errors";
                              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";
                              }
                            }  // container path-bbe-rs

                            leaf path-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container path

                          container fe-path {
                            description
                              "Far End PATH";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list ho-vc-minute15-path-time-line-instance
                      }  // container ho-vc-minute15-path-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list ho-vc-minute15-path-history
                  }  // container ho-vc-minute15-path-histories
                }  // container ho-vc-minute15-history

                container ho-vc-hour24-history {
                  description
                    "port current performance data";
                  container ho-vc-hour24-path-histories {
                    description
                      "port current performance data";
                    list ho-vc-hour24-path-history {
                      key "number";
                      description
                        "port 24 hour Path performance data";
                      container ho-vc-hour24-path-time-line-instances {
                        description
                          "port current performance data";
                        list ho-vc-hour24-path-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container path {
                            description
                              "PATH";
                            container path-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-e-ss

                            container path-es-rs {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container path-es-rs

                            container path-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-se-ss

                            container path-ses-rs {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container path-ses-rs

                            container path-e-bs {
                              description
                                "The number of Errored blocks";
                              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";
                              }
                            }  // container path-e-bs

                            container path-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container path-ua-ss

                            container path-bb-es {
                              description
                                "The number of background block errors";
                              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";
                              }
                            }  // container path-bb-es

                            container path-bbe-rs {
                              description
                                "The number of background block errors";
                              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";
                              }
                            }  // container path-bbe-rs

                            leaf path-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container path

                          container fe-path {
                            description
                              "Far End PATH";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list ho-vc-hour24-path-time-line-instance
                      }  // container ho-vc-hour24-path-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list ho-vc-hour24-path-history
                  }  // container ho-vc-hour24-path-histories
                }  // container ho-vc-hour24-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list ho-vc-port-history
            }  // container ho-vc-port-histories
          }  // container ho-vc-history

          container optics-history {
            description
              "OPTICS controller History performance data";
            container optics-port-histories {
              description
                "Port performance data";
              list optics-port-history {
                key "name";
                description
                  "Port performance data";
                container optics-hour24-history {
                  description
                    "port current performance data";
                  container optics-hour24-optics-histories {
                    description
                      "port 24 hour performance data";
                    list optics-hour24-optics-history {
                      key "number";
                      description
                        "port 24 hour optics performance data";
                      container optics-hour24-optics-time-line-instances {
                        description
                          "port current performance data";
                        list optics-hour24-optics-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container lbc-pc {
                            description
                              "LBC in percentage";
                            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";
                            }
                          }  // container lbc-pc

                          container opt {
                            description
                              "OPT";
                            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";
                            }
                          }  // container opt

                          container opr {
                            description
                              "OPR";
                            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";
                            }
                          }  // container opr

                          container cd {
                            description
                              "Chromatic Dispersion";
                            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";
                            }
                          }  // container cd

                          container dgd {
                            description
                              "Differential group Delay";
                            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";
                            }
                          }  // container dgd

                          container pmd {
                            description
                              "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                            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";
                            }
                          }  // container pmd

                          container sopmd {
                            description
                              "Second order Polarization Mode Dispersion";
                            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";
                            }
                          }  // container sopmd

                          container osnr {
                            description
                              "Optical Signal to Noise Ratio";
                            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";
                            }
                          }  // container osnr

                          container center-wavelength {
                            description
                              "Center Wavelength/Frequency";
                            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";
                            }
                          }  // container center-wavelength

                          container pdl {
                            description
                              "Polarization Dependent Loss";
                            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";
                            }
                          }  // container pdl

                          container pcr {
                            description
                              "Polarization Change Rate";
                            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";
                            }
                          }  // container pcr

                          container pn {
                            description
                              "Phase Noise";
                            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";
                            }
                          }  // container pn

                          container rx-sig-pow {
                            description
                              "Rx signal power";
                            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";
                            }
                          }  // container rx-sig-pow

                          container low-sig-freq-off {
                            description
                              "low freq sig off";
                            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";
                            }
                          }  // container low-sig-freq-off

                          container ampli-gain {
                            description
                              "Ampli Gain";
                            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";
                            }
                          }  // container ampli-gain

                          container ampli-gain-tilt {
                            description
                              "Ampli Gain Tilt";
                            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";
                            }
                          }  // container ampli-gain-tilt

                          container snr {
                            description
                              "SNR";
                            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";
                            }
                          }  // container snr

                          container snrax {
                            description
                              "SNR AX";
                            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";
                            }
                          }  // container snrax

                          container snrbx {
                            description
                              "SNR BX";
                            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";
                            }
                          }  // container snrbx

                          container snray {
                            description
                              "SNR AY";
                            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";
                            }
                          }  // container snray

                          container snrby {
                            description
                              "SNR BY";
                            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";
                            }
                          }  // container snrby

                          container sops1 {
                            description
                              "SOP S1";
                            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";
                            }
                          }  // container sops1

                          container sops2 {
                            description
                              "SOP S2";
                            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";
                            }
                          }  // container sops2

                          container sops3 {
                            description
                              "SOP S3";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list optics-hour24-optics-time-line-instance
                      }  // container optics-hour24-optics-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list optics-hour24-optics-history
                  }  // container optics-hour24-optics-histories

                  container optics-hour24fec-histories {
                    description
                      "port current performance data";
                    list optics-hour24fec-history {
                      key "number";
                      description
                        "port 24 hour fec performance data";
                      container optics-hour24fec-time-line-instances {
                        description
                          "port current performance data";
                        list optics-hour24fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list optics-hour24fec-time-line-instance
                      }  // container optics-hour24fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list optics-hour24fec-history
                  }  // container optics-hour24fec-histories
                }  // container optics-hour24-history

                container optics-second30-history {
                  description
                    "port current performance data";
                  container optics-second30-optics-histories {
                    description
                      "port current performance data";
                    list optics-second30-optics-history {
                      key "number";
                      description
                        "port 30-second optics performance data";
                      container optics-second30-optics-time-line-instances {
                        description
                          "port current performance data";
                        list optics-second30-optics-time-line-instance {
                          key "number";
                          description
                            "port 30 second otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container lbc-pc {
                            description
                              "LBC in percentage";
                            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";
                            }
                          }  // container lbc-pc

                          container opt {
                            description
                              "OPT";
                            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";
                            }
                          }  // container opt

                          container opr {
                            description
                              "OPR";
                            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";
                            }
                          }  // container opr

                          container cd {
                            description
                              "Chromatic Dispersion";
                            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";
                            }
                          }  // container cd

                          container dgd {
                            description
                              "Differential group Delay";
                            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";
                            }
                          }  // container dgd

                          container pmd {
                            description
                              "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                            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";
                            }
                          }  // container pmd

                          container sopmd {
                            description
                              "Second order Polarization Mode Dispersion";
                            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";
                            }
                          }  // container sopmd

                          container osnr {
                            description
                              "Optical Signal to Noise Ratio";
                            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";
                            }
                          }  // container osnr

                          container center-wavelength {
                            description
                              "Center Wavelength/Frequency";
                            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";
                            }
                          }  // container center-wavelength

                          container pdl {
                            description
                              "Polarization Dependent Loss";
                            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";
                            }
                          }  // container pdl

                          container pcr {
                            description
                              "Polarization Change Rate";
                            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";
                            }
                          }  // container pcr

                          container pn {
                            description
                              "Phase Noise";
                            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";
                            }
                          }  // container pn

                          container rx-sig-pow {
                            description
                              "Rx signal power";
                            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";
                            }
                          }  // container rx-sig-pow

                          container low-sig-freq-off {
                            description
                              "low freq sig off";
                            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";
                            }
                          }  // container low-sig-freq-off

                          container ampli-gain {
                            description
                              "Ampli Gain";
                            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";
                            }
                          }  // container ampli-gain

                          container ampli-gain-tilt {
                            description
                              "Ampli Gain Tilt";
                            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";
                            }
                          }  // container ampli-gain-tilt

                          container snr {
                            description
                              "SNR";
                            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";
                            }
                          }  // container snr

                          container snrax {
                            description
                              "SNR AX";
                            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";
                            }
                          }  // container snrax

                          container snrbx {
                            description
                              "SNR BX";
                            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";
                            }
                          }  // container snrbx

                          container snray {
                            description
                              "SNR AY";
                            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";
                            }
                          }  // container snray

                          container snrby {
                            description
                              "SNR BY";
                            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";
                            }
                          }  // container snrby

                          container sops1 {
                            description
                              "SOP S1";
                            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";
                            }
                          }  // container sops1

                          container sops2 {
                            description
                              "SOP S2";
                            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";
                            }
                          }  // container sops2

                          container sops3 {
                            description
                              "SOP S3";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list optics-second30-optics-time-line-instance
                      }  // container optics-second30-optics-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list optics-second30-optics-history
                  }  // container optics-second30-optics-histories

                  container optics-second30fec-histories {
                    description
                      "port current performance data";
                    list optics-second30fec-history {
                      key "number";
                      description
                        "port 30-second fec performance data";
                      container optics-second30fec-time-line-instances {
                        description
                          "port current performance data";
                        list optics-second30fec-time-line-instance {
                          key "number";
                          description
                            "port sec-30 fec performance data";
                          leaf number {
                            type uint32 {
                              range "1..30";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list optics-second30fec-time-line-instance
                      }  // container optics-second30fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list optics-second30fec-history
                  }  // container optics-second30fec-histories
                }  // container optics-second30-history

                container optics-minute15-history {
                  description
                    "port current performance data";
                  container optics-minute15-optics-histories {
                    description
                      "port current performance data";
                    list optics-minute15-optics-history {
                      key "number";
                      description
                        "port 15-minute optics performance data";
                      container optics-minute15-optics-time-line-instances {
                        description
                          "port current performance data";
                        list optics-minute15-optics-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container lbc {
                            description
                              "LBC";
                            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";
                            }
                          }  // container lbc

                          container lbc-pc {
                            description
                              "LBC in percentage";
                            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";
                            }
                          }  // container lbc-pc

                          container opt {
                            description
                              "OPT";
                            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";
                            }
                          }  // container opt

                          container opr {
                            description
                              "OPR";
                            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";
                            }
                          }  // container opr

                          container cd {
                            description
                              "Chromatic Dispersion";
                            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";
                            }
                          }  // container cd

                          container dgd {
                            description
                              "Differential group Delay";
                            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";
                            }
                          }  // container dgd

                          container pmd {
                            description
                              "Polarization Mode Dispersion , deprecated , use
sopmd instead which is duplicate of pmd";
                            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";
                            }
                          }  // container pmd

                          container sopmd {
                            description
                              "Second order Polarization Mode Dispersion";
                            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";
                            }
                          }  // container sopmd

                          container osnr {
                            description
                              "Optical Signal to Noise Ratio";
                            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";
                            }
                          }  // container osnr

                          container center-wavelength {
                            description
                              "Center Wavelength/Frequency";
                            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";
                            }
                          }  // container center-wavelength

                          container pdl {
                            description
                              "Polarization Dependent Loss";
                            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";
                            }
                          }  // container pdl

                          container pcr {
                            description
                              "Polarization Change Rate";
                            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";
                            }
                          }  // container pcr

                          container pn {
                            description
                              "Phase Noise";
                            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";
                            }
                          }  // container pn

                          container rx-sig-pow {
                            description
                              "Rx signal power";
                            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";
                            }
                          }  // container rx-sig-pow

                          container low-sig-freq-off {
                            description
                              "low freq sig off";
                            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";
                            }
                          }  // container low-sig-freq-off

                          container ampli-gain {
                            description
                              "Ampli Gain";
                            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";
                            }
                          }  // container ampli-gain

                          container ampli-gain-tilt {
                            description
                              "Ampli Gain Tilt";
                            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";
                            }
                          }  // container ampli-gain-tilt

                          container snr {
                            description
                              "SNR";
                            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";
                            }
                          }  // container snr

                          container snrax {
                            description
                              "SNR AX";
                            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";
                            }
                          }  // container snrax

                          container snrbx {
                            description
                              "SNR BX";
                            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";
                            }
                          }  // container snrbx

                          container snray {
                            description
                              "SNR AY";
                            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";
                            }
                          }  // container snray

                          container snrby {
                            description
                              "SNR BY";
                            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";
                            }
                          }  // container snrby

                          container sops1 {
                            description
                              "SOP S1";
                            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";
                            }
                          }  // container sops1

                          container sops2 {
                            description
                              "SOP S2";
                            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";
                            }
                          }  // container sops2

                          container sops3 {
                            description
                              "SOP S3";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list optics-minute15-optics-time-line-instance
                      }  // container optics-minute15-optics-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list optics-minute15-optics-history
                  }  // container optics-minute15-optics-histories

                  container optics-minute15fec-histories {
                    description
                      "port current performance data";
                    list optics-minute15fec-history {
                      key "number";
                      description
                        "port 15-minute fec performance data";
                      container optics-minute15fec-time-line-instances {
                        description
                          "port current performance data";
                        list optics-minute15fec-time-line-instance {
                          key "number";
                          description
                            "port 15-minute fec performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container ec-bits {
                            description
                              "EC BITS";
                            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";
                            }
                          }  // container ec-bits

                          container uc-words {
                            description
                              "UC WORDS";
                            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";
                            }
                          }  // container uc-words

                          container pre-fec-ber {
                            description
                              "Pre FEC BER";
                            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";
                            }
                          }  // container pre-fec-ber

                          container post-fec-ber {
                            description
                              "Post FEC BER";
                            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";
                            }
                          }  // container post-fec-ber

                          container q {
                            description "Q";
                            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";
                            }
                          }  // container q

                          container qmargin {
                            description
                              "Q Margin";
                            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";
                            }
                          }  // container qmargin

                          container qmargin-inst {
                            description
                              "Q Margin Instantaneous";
                            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";
                            }
                          }  // container qmargin-inst

                          container ec-words {
                            description
                              "EC Words";
                            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";
                            }
                          }  // 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";
                          }
                        }  // list optics-minute15fec-time-line-instance
                      }  // container optics-minute15fec-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list optics-minute15fec-history
                  }  // container optics-minute15fec-histories
                }  // container optics-minute15-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list optics-port-history
            }  // container optics-port-histories
          }  // container optics-history

          container oc-history {
            description
              "OC controller History performance data";
            container oc-port-histories {
              description
                "Port performance data";
              list oc-port-history {
                key "name";
                description
                  "Port performance data";
                container oc-hour24-history {
                  description
                    "port current performance data";
                  container oc-hour24ocn-histories {
                    description
                      "port current performance data";
                    list oc-hour24ocn-history {
                      key "number";
                      description
                        "port 24 hour ocn performance data";
                      container oc-hour24ocn-time-line-instances {
                        description
                          "port current performance data";
                        list oc-hour24ocn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute otn performance data";
                          leaf number {
                            type uint32 {
                              range "1";
                            }
                            description
                              "History Index number";
                          }

                          container section {
                            description
                              "SECTION";
                            container section-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container section-e-ss

                            container section-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container section-se-ss

                            container section-sef-ss {
                              description
                                "The number of Severely Errored Framing Seconds";
                              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";
                              }
                            }  // container section-sef-ss

                            container section-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container section-c-vs

                            leaf section-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container section

                          container line {
                            description
                              "LINE";
                            container line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container line-e-ss

                            container line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container line-se-ss

                            container line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container line-c-vs

                            container line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container line-ua-ss

                            container line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container line-fc-ls

                            leaf line-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container line

                          container fe-line {
                            description
                              "FarEnd LINE";
                            container far-end-line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-e-ss

                            container far-end-line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-se-ss

                            container far-end-line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container far-end-line-c-vs

                            container far-end-line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container far-end-line-ua-ss

                            container far-end-line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container far-end-line-fc-ls
                          }  // 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";
                          }
                        }  // list oc-hour24ocn-time-line-instance
                      }  // container oc-hour24ocn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list oc-hour24ocn-history
                  }  // container oc-hour24ocn-histories
                }  // container oc-hour24-history

                container oc-minute15-history {
                  description
                    "port current performance data";
                  container oc-minute15ocn-histories {
                    description
                      "port current performance data";
                    list oc-minute15ocn-history {
                      key "number";
                      description
                        "port 15-minute ocn performance data";
                      container oc-minute15ocn-time-line-instances {
                        description
                          "port current performance data";
                        list oc-minute15ocn-time-line-instance {
                          key "number";
                          description
                            "port 15-minute ocn performance data";
                          leaf number {
                            type uint32 {
                              range "1..32";
                            }
                            description
                              "History Index number";
                          }

                          container section {
                            description
                              "SECTION";
                            container section-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container section-e-ss

                            container section-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container section-se-ss

                            container section-sef-ss {
                              description
                                "The number of Severely Errored Framing Seconds";
                              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";
                              }
                            }  // container section-sef-ss

                            container section-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container section-c-vs

                            leaf section-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container section

                          container line {
                            description
                              "LINE";
                            container line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container line-e-ss

                            container line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container line-se-ss

                            container line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container line-c-vs

                            container line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container line-ua-ss

                            container line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container line-fc-ls

                            leaf line-status {
                              type int32;
                              description
                                " status of the interface";
                            }
                          }  // container line

                          container fe-line {
                            description
                              "FarEnd LINE";
                            container far-end-line-e-ss {
                              description
                                "The number of Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-e-ss

                            container far-end-line-se-ss {
                              description
                                "The number of Severely Errored Seconds";
                              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";
                              }
                            }  // container far-end-line-se-ss

                            container far-end-line-c-vs {
                              description
                                "The number of Coding Violations";
                              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";
                              }
                            }  // container far-end-line-c-vs

                            container far-end-line-ua-ss {
                              description
                                "The number of Unavailable Seconds";
                              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";
                              }
                            }  // container far-end-line-ua-ss

                            container far-end-line-fc-ls {
                              description
                                "The number of Failure counts Seconds";
                              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";
                              }
                            }  // container far-end-line-fc-ls
                          }  // 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";
                          }
                        }  // list oc-minute15ocn-time-line-instance
                      }  // container oc-minute15ocn-time-line-instances

                      leaf number {
                        type uint32;
                        description
                          "channel number";
                      }
                    }  // list oc-minute15ocn-history
                  }  // container oc-minute15ocn-histories
                }  // container oc-minute15-history

                leaf name {
                  type xr:Interface-name;
                  description "Port name";
                }
              }  // list oc-port-history
            }  // container oc-port-histories
          }  // container oc-history
        }  // container periodic
      }  // container global
    }  // container performance-management-history
  }  // module Cisco-IOS-XR-pmengine-oper