module Cisco-IOS-XR-adt-oper {

    yang-version 1;

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

    prefix adt-oper;

    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-adt-oper-sub2 {
      revision-date "2020-05-05";
    }
    include Cisco-IOS-XR-adt-oper-sub1 {
      revision-date "2020-05-05";
    }

    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 adt package operational data.

This module contains definitions
for the following management objects:
  adt: ADT operational data

Copyright (c) 2013-2020 by Cisco Systems, Inc.
All rights reserved.";

    revision "2020-05-05" {
      description
        "IOS XR 7.3.1 Initial version.";
    }

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

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

    semver:module-version "1.0.0";

    container adt {
      config false;
      description "ADT operational data";
      container statistics {
        description "ADT statistics";
        container input-stats {
          description "Input statistics";
          leaf total-input-messages {
            type uint32;
            description
              "Total input messages received by pal";
          }

          leaf total-output-messages {
            type uint32;
            description
              "Total output messages send to collector";
          }

          leaf total-collection-errors {
            type uint32;
            description
              "Total Collection errors";
          }

          leaf total-decode-errors {
            type uint32;
            description
              "Total decode errors";
          }

          leaf total-bytes-received {
            type uint64;
            units "byte";
            description
              "Total bytes received from MDT sensor";
          }

          leaf total-bytes-sent {
            type uint64;
            units "byte";
            description
              "Total bytes sent to collector ";
          }
        }  // container input-stats

        container output-stats {
          description "Output statistics";
          leaf total-output-messages {
            type uint32;
            description
              "Total output messages from selector";
          }

          leaf total-notify {
            type uint32;
            description "Total ADT notifies";
          }

          leaf total-hints {
            type uint32;
            description "Total Hints";
          }

          leaf total-pending-selector-messages {
            type uint32;
            description
              "Total pending selector messages not pushed to
MDT";
          }

          leaf total-mdt-reads {
            type uint32;
            description "Total MDT reads";
          }

          leaf total-edt-events {
            type uint32;
            description "Total EDT events";
          }
        }  // container output-stats

        container memory-stats {
          description "Memory statistics";
          leaf current-memory-total {
            type uint32;
            units "byte";
            description
              "Current memory usage Total in bytes";
          }

          leaf current-memory-py {
            type uint32;
            units "byte";
            description
              "Current memory usage Py in bytes";
          }

          leaf peak-memory-total {
            type uint32;
            units "byte";
            description
              "Peak memory usage Total in bytes";
          }

          leaf peak-memory-py {
            type uint32;
            units "byte";
            description
              "Peak memory usage Py in bytes";
          }
        }  // container memory-stats

        container tuner-stats {
          description "Tuner statistics";
          leaf tuner-state {
            type uint8;
            description
              "Current tuner state";
          }

          leaf sys-cpu-state {
            type uint8;
            description
              "system CPU state 1:OK 0:NOK";
          }

          leaf sys-mem-state {
            type uint8;
            description
              "system memory state 1:OK 0:NOK";
          }

          leaf proc-cpu-state {
            type uint8;
            description
              "adt process CPU state 1:OK 0:NOK";
          }

          leaf proc-soft-limit {
            type uint32;
            description
              "adt proc soft limit";
          }

          leaf proc-mem-state {
            type uint8;
            description
              "adt process  memory state 1:OK 0:NOK";
          }

          leaf default-path-collection-total {
            type uint64;
            description
              "total default path collections";
          }

          leaf default-path-collection-status {
            type uint8;
            description
              "status of default path collections 1:OK 0:NOK";
          }

          leaf user-path-collection-total {
            type uint64;
            description
              "total user path collections";
          }

          leaf user-path-collection-status {
            type uint8;
            description
              "status of user path collections 1:OK 0:NOK";
          }

          leaf time-in-curr-state {
            type uint64;
            units "second";
            description
              "time :seconds: spend in current state";
          }

          leaf sysdb-path-count {
            type uint64;
            description
              "count of sysdb paths collected by ADT";
          }

          leaf item-count {
            type uint64;
            description
              "item count collected by ADT";
          }

          leaf-list sys-cpu-stae {
            type uint32;
            max-elements 4;
            description
              "last 4 samples of system cpu";
          }

          leaf-list sys-mem-data {
            type uint32;
            max-elements 4;
            description
              "last 4 samples of system memory data";
          }

          leaf-list proc-cpu-stae {
            type uint32;
            max-elements 4;
            description
              "last 4 samples of adt process cpu";
          }

          leaf-list proc-mem-data {
            type uint32;
            max-elements 4;
            description
              "last 4 samples of adt process memory data";
          }

          leaf-list default-path-collection-missed-data {
            type uint32;
            max-elements 4;
            description
              "last 4 samples of missed collection for default
paths";
          }

          leaf-list user-path-collection-missed-data {
            type uint32;
            max-elements 4;
            description
              "last 4 samples of missed collection for user
paths";
          }
        }  // container tuner-stats

        container detector-stats {
          description "Detector statistics";
          leaf-list detector-state {
            type uint32;
            max-elements 4;
            description "detector state";
          }
        }  // container detector-stats

        leaf last-telemetry-message-timestamp {
          type uint64;
          description
            "Timestamp of last telemetry message received";
        }

        leaf last-selector-output-timestamp {
          type uint64;
          description
            "Timestanmp of last selector output";
        }
      }  // container statistics

      container adt-output {
        description
          "Data associated with the event triggered from
adt";
        list adt-event {
          description "adt event";
          leaf event-id {
            xr:event-telemetry "Subscribe Telemetry Event";
            type uint32;
            description
              "Event id used as key";
          }

          leaf change-description {
            type string;
            description "change description";
          }

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

          list change {
            description "change";
            leaf sensor-path {
              type string;
              description "sensor path";
            }

            leaf sensor-path-tags {
              type string;
              description "sensor path tags";
            }

            leaf sensor-path-message {
              type string;
              description
                "sensor path message";
            }

            list data {
              description "data";
              container value {
                description "value";
                container stringdata {
                  when "../value-type = '5'" {
                    description
                      "../value_type = '5'";
                  }
                  description "stringdata";
                  leaf val-str {
                    type string;
                    description "val str";
                  }
                }  // container stringdata

                container ip-prefix {
                  when
                    "../value-type = '19'" {
                    description
                      "../value_type = '19'";
                  }
                  description "ip prefix";
                  container ipv4-prefix {
                    when
                      "../prefix-type = '1'" {
                      description
                        "../prefix_type = '1'";
                    }
                    description
                      "ipv4 prefix";
                    leaf val-str {
                      type string;
                      description "val str";
                    }
                  }  // container ipv4-prefix

                  container ipv6-prefix {
                    when
                      "../prefix-type = '2'" {
                      description
                        "../prefix_type = '2'";
                    }
                    description
                      "ipv6 prefix";
                    leaf val-str {
                      type string;
                      description "val str";
                    }
                  }  // container ipv6-prefix

                  leaf prefix-type {
                    type int32;
                    description
                      "prefix type";
                  }
                }  // container ip-prefix

                leaf value-type {
                  type int32;
                  description "value type";
                }

                leaf not-set {
                  when "../value-type = '0'" {
                    description
                      "../value_type = '0'";
                  }
                  type uint32;
                  description "not set";
                }

                leaf val-u32 {
                  when "../value-type = '1'" {
                    description
                      "../value_type = '1'";
                  }
                  type uint32;
                  description "val u32";
                }

                leaf val-i32 {
                  when "../value-type = '2'" {
                    description
                      "../value_type = '2'";
                  }
                  type int32;
                  description "val i32";
                }

                leaf val-u64 {
                  when "../value-type = '3'" {
                    description
                      "../value_type = '3'";
                  }
                  type uint64;
                  description "val u64";
                }

                leaf val-i64 {
                  when "../value-type = '4'" {
                    description
                      "../value_type = '4'";
                  }
                  type int64;
                  description "val i64";
                }

                leaf val-counter32 {
                  when "../value-type = '6'" {
                    description
                      "../value_type = '6'";
                  }
                  type uint32;
                  description
                    "val counter32";
                }

                leaf val-zero-based-counter32 {
                  when "../value-type = '7'" {
                    description
                      "../value_type = '7'";
                  }
                  type uint32;
                  description
                    "val zero based counter32";
                }

                leaf val-counter64 {
                  when "../value-type = '8'" {
                    description
                      "../value_type = '8'";
                  }
                  type uint64;
                  description
                    "val counter64";
                }

                leaf val-zero-based-counter64 {
                  when "../value-type = '9'" {
                    description
                      "../value_type = '9'";
                  }
                  type uint64;
                  description
                    "val zero based counter64";
                }

                leaf val-guage32 {
                  when
                    "../value-type = '10'" {
                    description
                      "../value_type = '10'";
                  }
                  type uint32;
                  description "val guage32";
                }

                leaf val-gauge64 {
                  when
                    "../value-type = '11'" {
                    description
                      "../value_type = '11'";
                  }
                  type uint64;
                  description "val gauge64";
                }

                leaf val-timeticks {
                  when
                    "../value-type = '12'" {
                    description
                      "../value_type = '12'";
                  }
                  type uint64;
                  description
                    "val timeticks";
                }

                leaf val-timestamp {
                  when
                    "../value-type = '13'" {
                    description
                      "../value_type = '13'";
                  }
                  type uint64;
                  description
                    "val timestamp";
                }

                leaf val-ip-version {
                  when
                    "../value-type = '14'" {
                    description
                      "../value_type = '14'";
                  }
                  type Ip-version;
                  description
                    "val ip version";
                }

                leaf val-dscp {
                  when
                    "../value-type = '15'" {
                    description
                      "../value_type = '15'";
                  }
                  type uint32;
                  description "val dscp";
                }

                leaf val-ipv6-flow-label {
                  when
                    "../value-type = '16'" {
                    description
                      "../value_type = '16'";
                  }
                  type uint32;
                  description
                    "val ipv6 flow label";
                }

                leaf val-port-number {
                  when
                    "../value-type = '17'" {
                    description
                      "../value_type = '17'";
                  }
                  type uint32;
                  description
                    "val port number";
                }

                leaf val-as-number {
                  when
                    "../value-type = '18'" {
                    description
                      "../value_type = '18'";
                  }
                  type uint32;
                  description
                    "val as number";
                }
              }  // container value

              leaf timestamp {
                type uint64;
                description "timestamp";
              }
            }  // list data
          }  // list change
        }  // list adt-event
      }  // container adt-output

      container subscription-info {
        description
          "ADT subscription details";
        list sensor-group {
          description
            "Subscribed sensor groups";
          leaf sensor-group-name {
            type string;
            description "Sensor group name ";
          }

          list sensor-path {
            description "Sensor paths";
            leaf sensor-path {
              type string;
              description "Sensor path ";
            }

            leaf cadence {
              type uint32;
              units "second";
              description
                "Cadence in seconds";
            }

            leaf is-implicitly-added {
              type uint8;
              description
                "Is implicity added sensor-path";
            }

            leaf subscription-id {
              type uint64;
              description "Subscription Id ";
            }
          }  // list sensor-path
        }  // list sensor-group

        list missed-collection {
          description
            "Missed sensor group collections ";
          leaf sensor-group-name {
            type string;
            description "Sensor group name ";
          }

          list sensor-path {
            description "Sensor paths";
            leaf sensor-path {
              type string;
              description "Sensor path ";
            }

            leaf cadence {
              type uint32;
              units "second";
              description
                "Cadence in seconds";
            }

            leaf is-implicitly-added {
              type uint8;
              description
                "Is implicity added sensor-path";
            }

            leaf subscription-id {
              type uint64;
              description "Subscription Id ";
            }
          }  // list sensor-path
        }  // list missed-collection
      }  // container subscription-info
    }  // container adt
  }  // module Cisco-IOS-XR-adt-oper