module Cisco-IOS-XE-dre-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-dre-oper";

    prefix dre-xe-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for Data Redundancy Elimination operational data.
     Copyright (c) 2020-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-07-01" {
      description
        "Profiles support for Data Redundancy Elimination
       - Added support for DRE statistics brief
       - Deprecated internal fragmentation and buffer usage by module";
      reference
        "1.1.0";

    }

    revision "2021-03-01" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "1.1.0";
    cisco-semver:module-version "1.0.0";

    typedef dre-comp-type {
      type enumeration {
        enum "comp-invalid" {
          value 0;
          description
            "Compression type - invalid";
        }
        enum "comp-dre-only" {
          value 1;
          description
            "Compression type - DRE only";
        }
        enum "comp-lz-only" {
          value 2;
          description
            "Compression type - LZ only";
        }
        enum "comp-dre-lz" {
          value 3;
          description
            "Compression type - DRE + LZ";
        }
      }
      description "DRE comp type";
    }

    typedef dre-health-status {
      type enumeration {
        enum "dre-status-unknown" {
          value 0;
          description
            "DRE health status is unknown";
        }
        enum "dre-status-red" {
          value 1;
          description
            "DRE health status is red";
        }
        enum "dre-status-yellow" {
          value 2;
          description
            "DRE health status is yellow";
        }
        enum "dre-status-green" {
          value 3;
          description
            "DRE health status is green";
        }
        enum "dre-status-unavailable" {
          value 4;
          description
            "DRE health status is unavailable";
        }
        enum "dre-status-disabled" {
          value 5;
          description
            "DRE health status is disabled";
        }
      }
      description
        "Data Redundancy Elimination health status";
    }

    typedef dre-cache-status {
      type enumeration {
        enum "cache-status-inactive" {
          value 0;
          description "Cache is inactive";
        }
        enum "cache-status-init-in-progress" {
          value 1;
          description "Cache is in progress";
        }
        enum "cache-status-active" {
          value 2;
          description "Cache is active";
        }
        enum "cache-status-temp-failed" {
          value 3;
          description
            "Cache temporarily failed";
        }
        enum "cache-status-failed" {
          value 4;
          description "Cache is failed";
        }
      }
      description "Status of DRE cache";
    }

    typedef dre-profile-type {
      type enumeration {
        enum "dre-profile-unknown" {
          value 0;
          description
            "DRE profile type unknown";
        }
        enum "dre-profile-high" {
          value 1;
          description
            "DRE profile type high";
        }
        enum "dre-profile-medium" {
          value 2;
          description
            "DRE profile type medium";
        }
        enum "dre-profile-low" {
          value 3;
          description "DRE profile type low";
        }
        enum "dre-profile-small" {
          value 4;
          description
            "DRE profile type small";
        }
        enum "dre-profile-large" {
          value 5;
          description
            "DRE profile type large";
        }
        enum "dre-profile-extra-large" {
          value 6;
          description
            "DRE profile type extra large";
        }
        enum "dre-profile-extra-extra-large" {
          value 7;
          description
            "DRE profile type extra extra Large";
        }
      }
      description "DRE profile type";
    }

    typedef dre-alarms {
      type enumeration {
        enum "almid-dre-none" {
          value 0;
          description "Alarm ID none";
        }
        enum "almid-dre-disk-full" {
          value 1;
          description "Disk full alarm";
        }
        enum "almid-dre-cache-corrupted" {
          value 2;
          description
            "Cache corrupted alarm";
        }
        enum "almid-dre-over-fanout" {
          value 3;
          description "Over fanout alarm";
        }
        enum "almid-dre-disk-overload" {
          value 4;
          description "Disk overload alarm";
        }
        enum "almid-dre-maxconn-threshold" {
          value 5;
          description
            "Maximum connections threshold exceeded alarm";
        }
        enum "almid-dre-cpu-threshold" {
          value 6;
          description
            "CPU threshold exceeded alarm";
        }
        enum "almid-dre-init-failed" {
          value 7;
          description "Init failed alarm";
        }
      }
      description "DRE alarms";
    }

    typedef dre-hs-change-reason {
      type enumeration {
        enum "hs-reason-none" {
          value 0;
          description
            "Health status change reason - none";
        }
        enum "hs-reason-init-failed" {
          value 1;
          description
            "Health status reason - init failed";
        }
        enum "hs-reason-not-responding" {
          value 2;
          description
            "Health status reason - no response";
        }
        enum "hs-reason-cache-corrupted" {
          value 3;
          description
            "Health status reason - cache corrupted";
        }
        enum "hs-reason-disk-overload" {
          value 4;
          description
            "Health status change reason - disk overload";
        }
        enum "hs-reason-disk-full" {
          value 5;
          description
            "Health status change reason - disk full";
        }
        enum "hs-reason-cpu-threshold" {
          value 6;
          description
            "Health status change reason - CPU threshold";
        }
        enum "hs-reason-maxconn-threshold" {
          value 7;
          description
            "Health status change  - maximum connections threshold";
        }
        enum "hs-reason-rename-over-fanout" {
          value 8;
          description
            "Health status change reason - over fanout";
        }
      }
      description
        "DRE health status change reason";
    }

    typedef lz-algorithm {
      type enumeration {
        enum "lz-algo-unknown" {
          value 0;
          description "LZ LZO algorithm";
        }
        enum "lz-algo-zlib" {
          value 1;
          description "LZ ZLIB algorithm";
        }
        enum "lz-algo-lzo" {
          value 2;
          description "LZ LZO algorithm";
        }
      }
      description "Type of LZ algorithm";
    }

    typedef dre-state {
      type enumeration {
        enum "dre-state-unknown" {
          value 0;
          description "DRE state - Unknown";
        }
        enum "dre-state-monitor" {
          value 1;
          description "DRE state - Monitor";
        }
        enum "dre-state-bypass" {
          value 2;
          description "DRE state  - Bypass";
        }
      }
      description "DRE state";
    }

    typedef bypass-reason {
      type enumeration {
        enum "bypass-lowmem-bytes" {
          value 0;
          description
            "Bypass reason - Low memory bytes";
        }
        enum "bypass-out-of-sync" {
          value 1;
          description
            "Bypass reason - Out of sync";
        }
        enum "bypass-cache-not-ready" {
          value 2;
          description
            "Bypass reason - Cache not ready";
        }
        enum "bypass-rem-cache-not-ready" {
          value 3;
          description
            "Bypass reason - Remote cache not ready";
        }
        enum "bypass-cache-not-compatible" {
          value 4;
          description
            "Bypass reason - Remote cache not compatible";
        }
        enum "bypass-ackq-cap-exceed" {
          value 5;
          description
            "Bypass reason - Exceed ack-Q cap";
        }
        enum "bypass-remote-waitq-bytes" {
          value 6;
          description
            "Bypass reason - Remote wait-Q due to nack";
        }
        enum "bypass-disk-overld-bytes" {
          value 7;
          description
            "Bypass reason - Local disk overload";
        }
        enum "bytes-rem-disk-overld-bytes" {
          value 8;
          description
            "Bypass reason - Remote disk overload";
        }
        enum "reason-disk-io-err-bytes" {
          value 9;
          description
            "Bypass reason - Local disk IO error";
        }
        enum "bypass-rem-disk-io-err-bytes" {
          value 10;
          description
            "Bypass reason - Remote disk IO error";
        }
        enum
          "bypass-non-dre-comp-type-bytes" {
          value 11;
          description
            "Bypass reason - Non DRE compression type";
        }
        enum "bypass-chunk-bytes" {
          value 12;
          description
            "Bypass reason - Last partial chunk";
        }
        enum "bypass-skip-bytes" {
          value 13;
          description
            "Bypass reason - Skipped frame header";
        }
        enum "bypass-low-comp-bytes" {
          value 14;
          description
            "Bypass reason - DRE low compression auto bypass";
        }
      }
      description "DRE bypass reasons";
    }

    grouping active-alarms {
      description "Active alarms";
      leaf alarms-list {
        type dre-alarms;
        description "List of alarms";
      }
    }  // grouping active-alarms

    grouping appqoe-dre-config {
      description "AppQoE DRE detail status";
      leaf total-disk {
        type uint16;
        units "GB";
        description
          "Total available disk space";
      }

      leaf max-cons {
        type uint32;
        description
          "Maximum connections configured";
      }

      leaf max-fanout {
        type uint32;
        description "Maximum fanout";
      }

      leaf profile {
        type dre-profile-type;
        description "DRE profile type";
      }

      leaf total-memory {
        type uint64;
        units "MB";
        description "Total available memory";
      }

      leaf cpu-cores {
        type uint8;
        description "CPU cores";
      }

      leaf disk-encrypt {
        type boolean;
        description "DRE disk encryption";
      }

      leaf rep-accl-mode {
        type boolean;
        description
          "Replication accelerator mode ON/OFF";
      }

      leaf comp-type {
        type dre-comp-type;
        description "Compression Type";
      }

      leaf plz-mem {
        type uint32;
        units "MB";
        description "Persistent LZ memory";
      }

      leaf plz-buffer {
        type uint32;
        units "bytes";
        description
          "Persistent LZ buffer queue size";
      }

      leaf hash-table-mem {
        type uint32;
        units "MB";
        description "DRE hash table memory";
      }

      leaf plz-high-wm {
        type uint32;
        description
          "Persistent LZ high-watermark";
      }

      leaf plz-low-wm {
        type uint32;
        description
          "Persistent LZ low-watermark";
      }

      leaf wait-queue-cap {
        type uint32;
        units "MB";
        description "Wait queue capacity";
      }

      leaf max-data-unit {
        type uint32;
        description
          "Maximum data unit number";
      }

      leaf sig-read-pool {
        type uint32;
        units "bytes";
        description
          "Sign block read pool size";
      }

      leaf data-read-pool {
        type uint32;
        units "bytes";
        description
          "Data segment read pool size";
      }

      leaf anchor-distance {
        type uint32;
        description
          "Default anchor distance";
      }

      leaf section-size {
        type uint32;
        units "bytes";
        description "Default section size";
      }

      leaf avg-chunk-size {
        type uint32;
        units "bytes";
        description
          "Default average chunk size";
      }

      leaf min-chunk-size {
        type uint32;
        units "bytes";
        description
          "Default minimum chunk size";
      }

      leaf lookup-on {
        type boolean;
        description "Partial lookup ON/OFF";
      }

      leaf write-tshld {
        type uint32;
        description "Write threshold";
      }

      leaf cold-pass-tshld {
        type uint32;
        description "Cold pass threshold";
      }

      leaf algorithm {
        type lz-algorithm;
        description "LZ algorithm";
      }

      leaf lz-adaptive {
        type boolean;
        description "Adaptive LZ ON/OFF";
      }

      leaf lz-comp-level {
        type uint32;
        description "LZ compression level";
      }

      leaf lz-adaptive-thres {
        type uint32;
        description "Adaptive threshold";
      }

      leaf use-entropy {
        type boolean;
        description
          "Adaptive LZ uses entropy ON/OFF";
      }

      leaf plz-enabled {
        type boolean;
        description
          "Persistent LZ enabled YES/NO";
      }

      leaf big-msg-checksum {
        type boolean;
        description
          "Big message checksum ON/OFF";
      }

      leaf block-size {
        type uint32;
        units "bytes";
        description "Buffer block size";
      }
    }  // grouping appqoe-dre-config

    grouping dre-status-data {
      description "DRE status data";
      leaf dre-id {
        type string;
        description "DRE peer ID";
      }

      leaf dre-uptime {
        type yang:date-and-time;
        description "Uptime of DRE";
      }

      leaf hs-change-reason {
        type dre-hs-change-reason;
        description
          "DRE health status change reason";
      }

      leaf hs-change-time {
        type yang:date-and-time;
        description
          "Time from last DRE health status change";
      }

      leaf last-hs-update {
        type yang:date-and-time;
        description
          "Last DRE health status time";
      }

      leaf cache-status {
        type dre-cache-status;
        description "DRE cache status";
      }

      leaf disk-cache-usage {
        type uint8;
        units "percentage";
        description
          "Percentage of disk cache usage";
      }

      leaf disk-latency {
        type uint32;
        units "milliseconds";
        description "DRE disk latency";
      }

      list alarm {
        description "Alarms asserted";
        uses dre-xe-oper:active-alarms;
      }  // list alarm

      container config {
        description
          "Configuration in detail";
        uses dre-xe-oper:appqoe-dre-config;
      }  // container config
    }  // grouping dre-status-data

    grouping appqoe-dre-status {
      description "AppQoE DRE status";
      leaf health-status {
        type dre-health-status;
        description "DRE health status";
      }

      container data {
        when
          "(../health-status!='dre-status-unavailable' and ../health-status!='dre-status-disabled')";
        description "DRE status data";
        uses dre-xe-oper:dre-status-data;
      }  // container data
    }  // grouping appqoe-dre-status

    grouping appqoe-dre-auto-bypass-data {
      description "DRE auto-bypass data";
      leaf state {
        type dre-state;
        description "DRE state";
      }

      leaf dre-lan-bytes {
        type uint64;
        units "bytes";
        description "Total DRE LAN bytes";
      }

      leaf dre-wan-bytes {
        type uint64;
        units "bytes";
        description "Total DRE WAN bytes";
      }

      leaf dre-comp {
        type decimal64 {
          fraction-digits 2;
        }
        units "percentage";
        description "DRE reduction ratio";
      }

      leaf last-update {
        type yang:date-and-time;
        description "Last update timestamp";
      }

      leaf entry-creation-time {
        type yang:date-and-time;
        description
          "Last entry creation timestamp";
      }
    }  // grouping appqoe-dre-auto-bypass-data

    grouping appqoe-dre-auto-bypass-key {
      description "DRE auto-bypass key";
      leaf server-ip {
        type inet:ip-address;
        description "Server IP address";
      }

      leaf port {
        type uint16;
        description "Server port";
      }
    }  // grouping appqoe-dre-auto-bypass-key

    grouping comp-info {
      description "Compression information";
      leaf msg {
        type uint64;
        description "Number of messages";
      }

      leaf in {
        type uint64;
        units "bytes";
        description "Input bytes";
      }

      leaf out {
        type uint64;
        units "bytes";
        description "Output bytes";
      }

      leaf ratio {
        type uint16;
        units "percentage";
        description "Reduction ratio";
      }
    }  // grouping comp-info

    grouping msg-size-dist {
      description
        "Message size distribution";
      leaf kb-0-1 {
        type uint8;
        units "percentage";
        description
          "Total number of messages of size 0 to 1 KB ";
      }

      leaf kb-1-5 {
        type uint8;
        units "percentage";
        description
          "Total number of messages of size 1 to 5 KB";
      }

      leaf kb-5-15 {
        type uint8;
        units "percentage";
        description
          "Total number of messages of size 5 to 15 KB";
      }

      leaf kb-15-25 {
        type uint8;
        units "percentage";
        description
          "Total number of messages of size 15 to 25 KB";
      }

      leaf kb-25-40 {
        type uint8;
        units "percentage";
        description
          "Total number of messages of size 25 to 40 KB";
      }

      leaf kb-above-40 {
        type uint8;
        units "percentage";
        description
          "Total number of messages of size above 40 KB";
      }
    }  // grouping msg-size-dist

    grouping comp-details {
      description "Compression type details";
      container overall {
        description
          "Overall compression details";
        uses dre-xe-oper:comp-info;
      }  // container overall

      container dre {
        description
          "DRE compression details";
        uses dre-xe-oper:comp-info;
      }  // container dre

      container dre-bypass {
        description
          "DRE bypass compression details";
        uses dre-xe-oper:comp-info;
      }  // container dre-bypass

      container lz {
        description "LZ compression details";
        uses dre-xe-oper:comp-info;
      }  // container lz

      container lz-bypass {
        description
          "LZ bypass compression details";
        uses dre-xe-oper:comp-info;
      }  // container lz-bypass

      leaf avg-latency {
        type decimal64 {
          fraction-digits 2;
        }
        description "Average latency";
      }

      leaf avg-msg-size {
        type uint64;
        description "Average message size";
      }

      container msg-dist {
        description
          "Message size distribution";
        uses dre-xe-oper:msg-size-dist;
      }  // container msg-dist
    }  // grouping comp-details

    grouping latency-info {
      description "DRE latency info";
      leaf ms-per-msg {
        type decimal64 {
          fraction-digits 2;
        }
        units "milliseconds";
        description
          "Latency per message in milliseconds";
      }

      leaf avg-msg-size {
        type uint64;
        units "bytes";
        description "Average message size";
      }
    }  // grouping latency-info

    grouping dre-bypass-reason {
      description "Bypass reason details";
      leaf reason {
        type bypass-reason;
        description "Bypass reason";
      }

      leaf bypass-msgs {
        type uint64;
        description
          "Total number of messages bypassed";
      }

      leaf bypass-chunks {
        type uint64;
        description
          "Total number of chunks bypassed";
      }

      leaf bypass-size {
        type uint64;
        units "bytes";
        description
          "Total size of bypassed traffic";
      }
    }  // grouping dre-bypass-reason

    grouping dre-ack-queue {
      description "Acknowledgement queue";
      leaf total-size {
        type uint64;
        units "bytes";
        description
          "Total size of ACK queue";
      }

      leaf used-size {
        type uint64;
        units "bytes";
        description "Used ACK queue size";
      }

      leaf wait-queue {
        type uint64;
        description "ACK queue wait size";
      }

      leaf disk-write {
        type uint64;
        description "Total ACK disk writes";
      }

      leaf optimized-size {
        type uint64;
        units "bytes";
        description
          "Size of optimized ACK queue";
      }

      leaf object-buff-size {
        type uint64;
        units "bytes";
        description
          "Size of ACK queue buffer";
      }

      leaf numbers {
        type uint64;
        description
          "Total number of ACK queues";
      }
    }  // grouping dre-ack-queue

    grouping dre-low-mem-errors {
      description "DRE low memory errors";
      leaf open {
        type uint64;
        description "Open errors";
      }

      leaf decode {
        type uint64;
        description
          "Total number of decode errors";
      }

      leaf malloc {
        type uint64;
        description
          "Total number of malloc errors";
      }

      leaf plz-off {
        type uint64;
        description
          "Total number of persistent LZ off errors";
      }

      leaf minres {
        type uint64;
        description
          "Total number of minimum resource errors";
      }
    }  // grouping dre-low-mem-errors

    grouping dre-twin-pool {
      description "DRE twin pool";
      leaf big-used {
        type uint64;
        description "Big used";
      }

      leaf big-free {
        type uint64;
        description "Big free";
      }

      leaf small-used {
        type uint64;
        description "Small used";
      }

      leaf small-free {
        type uint64;
        description "Small free";
      }

      leaf defragment {
        type uint64;
        description "Defragment";
      }
    }  // grouping dre-twin-pool

    grouping buffer-by-module {
      description
        "Used buffer by module name";
      leaf module-name {
        type string;
        status deprecated;
        description "Module name";
      }

      leaf used-units {
        type uint64;
        status deprecated;
        description
          "Units used by the module";
      }

      leaf used-bytes {
        type uint64;
        units "bytes";
        status deprecated;
        description
          "Bytes used by the module";
      }
    }  // grouping buffer-by-module

    grouping dre-stats-data {
      description "DRE statistics data";
      leaf cache-status {
        type dre-cache-status;
        description "Cache status";
      }

      leaf cache-oldest-data {
        when
          "../cache-status='cache-status-active'";
        type yang:date-and-time;
        description "Oldest data in cache";
      }

      leaf max-cons {
        type uint32;
        description
          "Maximum connections configured";
      }

      leaf cache-size {
        type uint64;
        units "bytes";
        description "Total cache size";
      }

      leaf cache-used-percent {
        type uint16;
        units "percentage";
        description
          "Percentage of cache used";
      }

      leaf data-replaced {
        type uint64;
        description
          "Data units replaced in last hour";
      }

      leaf total-cons {
        type uint64;
        description
          "Total number of connections";
      }

      leaf active-cons {
        type uint64;
        description
          "Number of active connections";
      }

      leaf total-orig-bytes {
        type uint64;
        units "bytes";
        description "Total original bytes";
      }

      leaf total-opt-bytes {
        type uint64;
        units "bytes";
        description "Total optimized bytes";
      }

      leaf reduction-ratio {
        type uint16;
        units "percentage";
        description "Reduction ratio";
      }

      leaf total-usable-disk {
        type uint64;
        units "bytes";
        description "Total usable disk size";
      }

      leaf total-usable-disk-usage {
        type uint8;
        units "percentage";
        description
          "Total usable disk size usage";
      }

      leaf hash-tbl-ram-size {
        type uint64;
        units "bytes";
        description "Hash table RAM size";
      }

      leaf hash-tbl-ram-usage {
        type uint8;
        units "percentage";
        description "Hash table RAM usage";
      }

      leaf sig-block-disk-usage {
        type uint64;
        units "percentage";
        description
          "Signature block disk usage";
      }

      leaf sig-block-mem-usage {
        type uint8;
        units "percentage";
        description
          "Signature block memory usage";
      }

      leaf sig-block-time {
        type yang:date-and-time;
        description
          "Signature block creation timestamp";
      }

      leaf data-unit-disk-usage {
        type uint8;
        units "bytes";
        description "Data unit disk usage";
      }

      leaf data-unit-mem-usage {
        type uint8;
        units "percentage";
        description "Data unit memory usage";
      }

      leaf data-unit-time {
        type yang:date-and-time;
        description
          "Data unit creation timestamp";
      }

      leaf cache-created-time {
        when
          "../cache-status='cache-status-active'";
        type yang:date-and-time;
        description
          "Cache creation timestamp";
      }

      leaf evicted-cache {
        type uint64;
        units "bytes";
        description
          "Evicted cache in loading cache";
      }

      leaf sigblock-replaced-size {
        type uint64;
        units "bytes";
        description
          "Size of signature block replaced in last hour";
      }

      leaf sigblock-replaced-sec {
        type uint64;
        description
          "Sections of signature block replaced in last hour";
      }

      leaf data-unit-replaced-size {
        type uint64;
        units "bytes";
        description
          "Size of data unit replaced in last hour";
      }

      leaf data-unit-replaced-sec {
        type uint64;
        description
          "Section of data unit replaced in last hour";
      }

      leaf sigblock-size {
        type uint64;
        units "bytes";
        description "Size of sigblock";
      }

      leaf sigblock-count {
        type uint64;
        description "Signature block count";
      }

      leaf data-unit-size {
        type uint64;
        units "bytes";
        description "Size of data unit";
      }

      leaf data-unit-count {
        type uint64;
        description "Total data units";
      }

      leaf data-unit-seg-count {
        type uint64;
        description
          "Total data unit segments";
      }

      leaf data-unit-seg-size {
        type uint64;
        units "bytes";
        description "Data unit segment size";
      }

      leaf ng-clock-head {
        type uint64;
        description
          "Next generation clock head";
      }

      leaf ng-clock-tail {
        type uint64;
        description
          "Next generation clock tail";
      }

      leaf total-read-latency {
        type uint64;
        units "milliseconds";
        description "Total read latency";
      }

      leaf total-read-count {
        type uint64;
        description "Total number of reads";
      }

      leaf total-disk-read-latency {
        type uint64;
        units "milliseconds";
        description
          "Total disk read latency";
      }

      leaf total-disk-read-count {
        type uint64;
        description
          "Total number of disk reads";
      }

      leaf table-full-events {
        type uint64;
        description "Full events";
      }

      leaf sig-events {
        type uint64;
        description "Signal events";
      }

      leaf type-two-events {
        type uint64;
        description "Type 2 events";
      }

      leaf type-three-events {
        type uint64;
        description "Type 3 events";
      }

      leaf sigblock-total-chunks {
        type uint64;
        description
          "Total number of sigblock chunks";
      }

      leaf sigblock-total-sec {
        type uint64;
        description
          "Total number of sigblock sections";
      }

      leaf secblock-total-chunks {
        type uint64;
        description
          "Total number of secblock chunks";
      }

      leaf secblock-total-sec {
        type uint64;
        description
          "Total number of secblock sections";
      }

      leaf total-anchor-seen {
        type uint64;
        description
          "Total number of anchors seen";
      }

      leaf total-matches-seen {
        type uint64;
        description
          "Total number of matches seen";
      }

      leaf matches {
        type uint64;
        description
          "Total number of multiple matches";
      }

      container ack-queue {
        description "Acknowledgement queue";
        uses dre-xe-oper:dre-ack-queue;
      }  // container ack-queue

      container errors {
        description "DRE low memory errors";
        uses dre-xe-oper:dre-low-mem-errors;
      }  // container errors

      leaf chunk-mem-used {
        type uint64;
        units "bytes";
        description
          "Chunk aggregation node memory consumption";
      }

      container twin-pool {
        description "Twin pool statistics";
        uses dre-xe-oper:dre-twin-pool;
      }  // container twin-pool

      leaf encode-plz-on-conn {
        type uint64;
        description
          "Encode - Persistent LZ-ON connections";
      }

      leaf encode-plz-off-conn {
        type uint64;
        description
          "Encode - Persistent LZ-OFF connections";
      }

      leaf encode-msg-size {
        type uint64;
        units "bytes";
        description
          "Encode - Average message size";
      }

      leaf decode-disk-read {
        type uint64;
        description
          "Decode - Total disk read";
      }

      leaf decode-disk-write {
        type uint64;
        description
          "Decode - Total disk write";
      }

      leaf decode-plz-on-conn {
        type uint64;
        description
          "Decode - Persistent LZ-ON connections";
      }

      leaf decode-plz-off-conn {
        type uint64;
        description
          "Decode - Persistent LZ-OFF connections";
      }

      leaf decode-plz-num-in-disc {
        type uint64;
        description
          "Decode - Average message size";
      }

      container encode {
        description "Encode details";
        uses dre-xe-oper:comp-details;
      }  // container encode

      container decode {
        description "Decode details";
        uses dre-xe-oper:comp-details;
      }  // container decode

      list bypass-reason-list {
        description "Bypass reason";
        uses dre-xe-oper:dre-bypass-reason;
      }  // list bypass-reason-list

      leaf nack-msgs {
        type uint64;
        description "Total NACK messages";
      }

      leaf num-col-nack-msgs {
        type uint64;
        description
          "Total number of NACK collision messages received";
      }

      leaf num-miss-nack-msgs {
        type uint64;
        description
          "Total number of chunk miss NACK messages received";
      }

      leaf cache-not-ready-nack {
        type uint64;
        description
          "Total number of cache not ready NACK messages received";
      }

      leaf rtx-msgs {
        type uint64;
        description
          "Total number of retransmitted messages";
      }

      leaf num-col-rtx-msgs {
        type uint64;
        description
          "Total number of collision messages received";
      }

      leaf num-miss-rtx-msgs {
        type uint64;
        description
          "Total number of chunk miss messages received";
      }

      leaf cache-not-ready-rtx {
        type uint64;
        description
          "Total number of cache not ready messages received";
      }

      container encode-latency {
        description "Latency in encode";
        uses dre-xe-oper:latency-info;
      }  // container encode-latency

      container decode-latency {
        description "Latency in decode";
        uses dre-xe-oper:latency-info;
      }  // container decode-latency

      leaf num-invalid-sections {
        type uint64;
        description
          "Total number of invalid sections";
      }

      leaf convert-invalid-sections {
        type uint64;
        description
          "Total number of converted invalid sections due to corrupted cache";
      }

      leaf disk-space-saving {
        type uint64;
        units "bytes";
        description
          "Disk size saved due to unidirectional mode";
      }

      leaf total-buf-size {
        type uint64;
        units "bytes";
        description "Total buffer pool size";
      }

      leaf unit-size {
        type uint64;
        units "bytes";
        description "Unit size";
      }

      leaf free-buf-size {
        type uint64;
        units "bytes";
        description
          "Free buffer size in bytes";
      }

      leaf free-buf-units {
        type uint64;
        description
          "Free buffer size in units";
      }

      leaf used-buf-size {
        type uint64;
        units "bytes";
        description
          "Used buffer size in bytes";
      }

      leaf used-buf-units {
        type uint64;
        description
          "Used buffer size in units";
      }

      leaf frag {
        type uint64;
        units "percentage";
        status deprecated;
        description
          "Percentage of internal fragmentation for used buffers";
      }

      list module {
        status deprecated;
        description "Buffer usage by module";
        uses dre-xe-oper:buffer-by-module;
      }  // list module

      leaf internal-resets {
        type uint64;
        description
          "Total number of internal resets generated by DRE";
      }

      leaf write-failed {
        type uint64;
        description
          "Total number of DRE Socket write failures";
      }

      leaf read-failed {
        type uint64;
        description
          "Total number of DRE Socket read failures";
      }

      leaf decode-failed {
        type uint64;
        description
          "Total number of DRE decode failures";
      }

      leaf encode-failed {
        type uint64;
        description
          "Total number of DRE encode failures";
      }

      leaf conn-init-failed {
        type uint64;
        description
          "Total number of DRE Connection init failures";
      }

      leaf opt-read-unexp-hup {
        type uint64;
        description
          "Total number of times WAN socket received unexpected closes while waiting to read";
      }

      leaf bufmgr-call-failed {
        type uint64;
        description
          "Total number of buffer allocation or manipulation failures";
      }

      leaf peer-req-reset-close {
        type uint64;
        description
          "Total number of times peer received reset from end host";
      }

      leaf state-invalid {
        type uint64;
        description
          "Total number of times DRE connection state was out of sync";
      }

      leaf bufhead-alloc-failed {
        type uint64;
        description
          "Total number of times memory allocation failed for buffer heads";
      }

      leaf other {
        type uint64;
        description
          "Total number of other error in connection";
      }

      leaf buf-ctrl-pause-ackq {
        type uint64;
        description
          "Total number of times connection was paused due to ack queue block";
      }

      leaf buf-ctrl-pause-buf {
        type uint64;
        description
          "Total number of times connection was paused due to buffer control";
      }

      leaf data-ebp-recvd {
        type uint64;
        description
          "Total number of data buffers received";
      }

      leaf data-ebp-freed {
        type uint64;
        description
          "Total number of data buffers freed";
      }

      leaf data-ebp-alloc {
        type uint64;
        description
          "Total number of data buffers allocated";
      }

      leaf data-ebp-sent {
        type uint64;
        description
          "Total number of data buffers sent";
      }

      leaf data-ebp-send-fail {
        type uint64;
        description
          "Total number of data buffers send failed";
      }

      leaf data-ebp-no-flow-ctx {
        type uint64;
        description
          "Total number of data buffers received with no flow context";
      }

      leaf data-ebp-req-more {
        type uint64;
        description
          "Total number of data buffers whose requested size was greater than max size";
      }

      leaf data-ebp-ret-less {
        type uint64;
        description
          "Total number of data buffers whose size was less than requested size";
      }

      leaf ctrl-ebp-recvd {
        type uint64;
        description
          "Total number of control buffers received";
      }

      leaf ctrl-ebp-freed {
        type uint64;
        description
          "Total number of control buffers freed";
      }

      leaf ctrl-ebp-reused {
        type uint64;
        description
          "Total number of control buffers reused";
      }

      leaf ctrl-ebp-alloc {
        type uint64;
        description
          "Total number of control buffers allocated";
      }

      leaf ctrl-ebp-sent {
        type uint64;
        description
          "Total number of control buffers sent";
      }

      leaf ctrl-ebp-send-fail {
        type uint64;
        description
          "Total number of control buffers send failed";
      }

      leaf ctrl-ebp-no-flow-ctx {
        type uint64;
        description
          "Total number of control buffers received with no flow context";
      }

      leaf ctrl-ebp-req-more {
        type uint64;
        description
          "Total number of control buffer whose requested size was greater than max size";
      }

      leaf ctrl-ebp-ret-less {
        type uint64;
        description
          "Total number of control buffer size was less than requested size";
      }

      leaf conn-alloc {
        type uint64;
        description
          "Total number of times connection is allocated";
      }

      leaf conn-free {
        type uint64;
        description
          "Total number of times connection is freed";
      }
    }  // grouping dre-stats-data

    grouping appqoe-dre-stats {
      description
        "DRE operational statistics detail";
      leaf health-status {
        type dre-health-status;
        description "DRE health status";
      }

      container data {
        when
          "(../health-status!='dre-status-unavailable' and ../health-status!='dre-status-disabled')";
        description "DRE statistics data";
        uses dre-xe-oper:dre-stats-data;
      }  // container data
    }  // grouping appqoe-dre-stats

    grouping dre-stats-data-brief {
      description "DRE statistics data";
      leaf cache-status {
        type dre-cache-status;
        description "Cache status";
      }

      leaf cache-oldest-data {
        when
          "../cache-status='cache-status-active'";
        type yang:date-and-time;
        description "Oldest data in cache";
      }

      leaf max-cons {
        type uint32;
        description
          "Maximum connections configured";
      }

      leaf cache-size {
        type uint64;
        units "bytes";
        description "Total cache size";
      }

      leaf cache-used-percent {
        type uint16;
        units "percentage";
        description
          "Percentage of cache used";
      }

      leaf data-replaced {
        type uint64;
        description
          "Data units replaced in last hour";
      }

      leaf total-cons {
        type uint64;
        description
          "Total number of connections";
      }

      leaf active-cons {
        type uint64;
        description
          "Number of active connections";
      }

      leaf total-orig-bytes {
        type uint64;
        units "bytes";
        description "Total original bytes";
      }

      leaf total-opt-bytes {
        type uint64;
        units "bytes";
        description "Total optimized bytes";
      }

      leaf reduction-ratio {
        type uint16;
        units "percentage";
        description "Reduction ratio";
      }

      leaf total-usable-disk-usage {
        type uint8;
        units "percentage";
        description
          "Total usable disk size usage";
      }

      leaf internal-resets {
        type uint64;
        description
          "Total number of internal resets generated by DRE";
      }
    }  // grouping dre-stats-data-brief

    grouping appqoe-dre-stats-summary {
      description
        "DRE operational statistics detail";
      leaf health-status {
        type dre-health-status;
        description "DRE health status";
      }

      container data {
        when
          "(../health-status!='dre-status-unavailable' and ../health-status!='dre-status-disabled')";
        description "DRE statistics data";
        uses dre-xe-oper:dre-stats-data-brief;
      }  // container data
    }  // grouping appqoe-dre-stats-summary

    grouping appqoe-dre-stats-peer {
      description "DRE peers details";
      leaf peer-no {
        type uint8;
        description "Peer number";
      }

      leaf system-ip {
        type inet:ip-address;
        description "System IP";
      }

      leaf hostname {
        type string;
        description "Hostname of peer";
      }

      leaf active-cons {
        type uint64;
        description
          "Total number of active connections";
      }

      leaf total-cons {
        type uint64;
        description
          "Total number of connections";
      }
    }  // grouping appqoe-dre-stats-peer

    grouping buffer-surge-ctrl {
      description
        "Buffer surge control details";
      leaf size {
        type uint64;
        units "bytes";
        description "Average size";
      }

      leaf conns {
        type uint64;
        description "Number of connections";
      }

      leaf flush {
        type uint64;
        description "Received flush";
      }
    }  // grouping buffer-surge-ctrl

    grouping appqoe-dre-peer {
      description "DRE peers details";
      leaf total-cons {
        type uint64;
        description
          "Total number of connections";
      }

      leaf active-cons {
        type uint64;
        description
          "Total number of active connections";
      }

      leaf peer-no {
        type uint32;
        description "Peer number";
      }

      leaf system-ip {
        type inet:ip-address;
        description "System IP of peer";
      }

      leaf hostname {
        type string;
        description "Hostname of peer";
      }

      leaf context-number {
        type uint64;
        description "Context number of peer";
      }

      leaf peer-id {
        type string;
        description "DRE peer ID";
      }

      leaf max-concurrent-cons {
        type uint64;
        description
          "Maximum concurrent connections";
      }

      leaf num-avg-cons {
        type uint64;
        description
          "Average number of connections";
      }

      leaf num-nacks {
        type uint64;
        description "Total NACK messages";
      }

      leaf num-rtx {
        type uint64;
        description
          "Total number of retransmitted messages";
      }

      leaf num-ctx-out-of-sync {
        type uint64;
        description
          "Number of out of sync messages";
      }

      leaf cache-used {
        type uint64;
        units "MB";
        description "Total cache used";
      }

      container encode {
        description "Encode details";
        uses dre-xe-oper:comp-details;
      }  // container encode

      container decode {
        description "Decode details";
        uses dre-xe-oper:comp-details;
      }  // container decode

      leaf sig-block-used {
        type uint64;
        units "MB";
        description
          "Signature block disk used";
      }

      leaf sig-block-time {
        type yang:date-and-time;
        description
          "Signature block creation timestamp";
      }

      leaf data-unit-disk-used {
        type uint64;
        units "MB";
        description "Data unit disk used";
      }

      leaf data-unit-time {
        type yang:date-and-time;
        description
          "Data unit creation timestamp";
      }

      leaf ack-queue-size {
        type uint64;
        units "bytes";
        description
          "Acknowledgement queue size";
      }

      container delay {
        description
          "Buffer surge control delay";
        uses dre-xe-oper:buffer-surge-ctrl;
      }  // container delay

      container agg-ft {
        description
          "Buffer surge control aggregate and full tree";
        uses dre-xe-oper:buffer-surge-ctrl;
      }  // container agg-ft

      leaf remote-low-buff {
        type uint64;
        description "Remote low buffer";
      }

      leaf received-flush {
        type uint64;
        description "Remote received flush";
      }

      leaf usable-cache-size {
        type uint64;
        units "MB";
        description "Usable cache size";
      }

      leaf usable-cache-time {
        type yang:date-and-time;
        description
          "Usable cache creation timestamp";
      }

      leaf evicted-cache {
        type uint64;
        units "bytes";
        description "Evicted cache size";
      }

      leaf cache-created-time {
        type yang:date-and-time;
        description
          "Cache creation timestamp";
      }

      leaf rtt-max {
        type uint64;
        units "milliseconds";
        description "Round trip time max";
      }

      leaf rtt-avg {
        type uint64;
        units "milliseconds";
        description
          "Round trip time average";
      }

      leaf rtt-remote {
        type uint64;
        units "milliseconds";
        description "Round trip time remote";
      }

      leaf dre-decode {
        type uint64;
        units "bytes per second";
        description
          "Per connection decode throughput DRE";
      }

      leaf bypass-decode {
        type uint64;
        units "bytes per second";
        description
          "Per connection decode throughput bypass";
      }

      leaf bypass-ratio {
        type uint8;
        units "percentage";
        description "Bypass ratio";
      }

      leaf sigblock-write {
        type uint64;
        description
          "Allocated write sig-block";
      }

      leaf data-unit-write {
        type uint64;
        description
          "Allocated write data-unit";
      }
    }  // grouping appqoe-dre-peer

    grouping appqoe-dre-peer-detail {
      description "DRE peer detail";
      leaf active-cons {
        type uint64;
        description
          "Current number of peers with active connections";
      }

      leaf peer-active {
        type uint64;
        description
          "Maximum number of peers with active connections";
      }

      list appqoe-dre-peer {
        key "system-ip";
        description
          "List of peers with details";
        uses dre-xe-oper:appqoe-dre-peer;
      }  // list appqoe-dre-peer
    }  // grouping appqoe-dre-peer-detail

    container dre-oper-data {
      config false;
      description
        "Data Redundancy Elimination operational data";
      container appqoe-dre-status {
        presence "appqoe-dre-status";
        description
          "Data Redundancy Elimination operational status";
        uses dre-xe-oper:appqoe-dre-status;
      }  // container appqoe-dre-status

      list appqoe-dre-auto-bypass {
        key "server-ip port";
        description
          "Data Redundancy Elimination auto-bypass details";
        uses dre-xe-oper:appqoe-dre-auto-bypass-data;

        uses dre-xe-oper:appqoe-dre-auto-bypass-key;
      }  // list appqoe-dre-auto-bypass

      container appqoe-dre-stats {
        presence "appqoe-dre-stats";
        description
          "Data Redundancy Elimination operational statistics";
        uses dre-xe-oper:appqoe-dre-stats;
      }  // container appqoe-dre-stats

      container appqoe-dre-stats-summary {
        presence "appqoe-dre-stats-summary";
        description
          "Data Redundancy Elimination operational statistics brief";
        uses dre-xe-oper:appqoe-dre-stats-summary;
      }  // container appqoe-dre-stats-summary

      list appqoe-dre-stats-peer {
        key "system-ip";
        description
          "Data Redundancy Elimination peer data";
        uses dre-xe-oper:appqoe-dre-stats-peer;
      }  // list appqoe-dre-stats-peer

      container appqoe-dre-peer-detail {
        presence "appqoe-dre-peer-detail";
        description
          "DRE operation peer data";
        uses dre-xe-oper:appqoe-dre-peer-detail;
      }  // container appqoe-dre-peer-detail
    }  // container dre-oper-data
  }  // module Cisco-IOS-XE-dre-oper