submodule Cisco-IOS-XR-telemetry-model-driven-oper-sub2 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-telemetry-model-driven-oper {
        prefix
          Cisco-IOS-XR-telemetry-model-driven-oper;
    }

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

    organization "Cisco Systems, Inc.";

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

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

    revision "2020-10-30" {
      description
        "Keys for sensor-paths IosSetYangSchemaRev Cisco-IOS-XR-telemetry-model-driven-oper";
    }

    revision "2020-03-11" {
      description
        "Updated the encodings supported
       2020-01-30
       Added compression leaf to destination container
       2020-01-10
       GRPC channel statistics added
       2019-09-25
       Added minimum-cadence and cadence-factor options for target defined mode";
    }

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

    revision "2017-09-27" {
      description "Summary container added";
    }

    revision "2017-05-05" {
      description
        "Modified the type for the state variables";
    }

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

    revision "2017-02-09" {
      description "Added DSCP";
    }

    revision "2017-01-30" {
      description "Initial 6.2.1 revision";
    }

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

    semver:module-version "1.2.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.1";

    typedef Mdt-source-qos-marking {
      type enumeration {
        enum "dscp-default" {
          value 0;
          description "0";
        }
        enum "dscp-cs1" {
          value 8;
          description "8";
        }
        enum "dscp-af11" {
          value 10;
          description "10";
        }
        enum "dscp-af12" {
          value 12;
          description "12";
        }
        enum "dscp-af13" {
          value 14;
          description "14";
        }
        enum "dscp-cs2" {
          value 16;
          description "16";
        }
        enum "dscp-af21" {
          value 18;
          description "18";
        }
        enum "dscp-af22" {
          value 20;
          description "20";
        }
        enum "dscp-af23" {
          value 22;
          description "22";
        }
        enum "dscp-cs3" {
          value 24;
          description "24";
        }
        enum "dscp-af31" {
          value 26;
          description "26";
        }
        enum "dscp-af32" {
          value 28;
          description "28";
        }
        enum "dscp-af33" {
          value 30;
          description "30";
        }
        enum "dscp-cs4" {
          value 32;
          description "32";
        }
        enum "dscp-af41" {
          value 34;
          description "34";
        }
        enum "dscp-af42" {
          value 36;
          description "36";
        }
        enum "dscp-af43" {
          value 38;
          description "38";
        }
        enum "dscp-cs5" {
          value 40;
          description "40";
        }
        enum "dscp-ef" {
          value 46;
          description "46";
        }
        enum "dscp-cs6" {
          value 48;
          description "48";
        }
        enum "dscp-cs7" {
          value 56;
          description "56";
        }
      }
      description
        "DSCP source qos value for subscription";
    }

    typedef Mdt-subs-state-enum {
      type enumeration {
        enum "not-active" {
          value 0;
          description "NA";
        }
        enum "active" {
          value 1;
          description "Active";
        }
        enum "paused" {
          value 2;
          description "Paused";
        }
      }
      description "Subscription State";
    }

    typedef Mdt-internal-path-status {
      type enumeration {
        enum "active" {
          value 0;
          description "Active";
        }
        enum "internal-err" {
          value 1;
          description "Internal Error";
        }
        enum "plugin-active" {
          value 2;
          description "Plugin Active";
        }
        enum "plugin-not-initialized" {
          value 3;
          description
            "Plugin Not Initialized";
        }
        enum "plugin-invalid-cadence" {
          value 4;
          description
            "Plugin Unsupported Cadence";
        }
        enum "plugin-err" {
          value 5;
          description
            "Plugin Subscription Error";
        }
        enum "filter-err" {
          value 6;
          description "Filter Error";
        }
        enum "paused" {
          value 7;
          description "Paused";
        }
        enum "event-ing-active" {
          value 8;
          description "Eventing Active";
        }
        enum "event-ing-not-active" {
          value 9;
          description "Eventing Not Active";
        }
        enum "event-ing-err" {
          value 10;
          description "Eventing Error";
        }
        enum "filter-invalid-key" {
          value 11;
          description "Filter Key Invalid";
        }
        enum "filter-unsupported" {
          value 12;
          description "Filter Unsupported";
        }
      }
      description
        "Internal Subscription Path Status";
    }

    typedef Mdt-compression {
      type enumeration {
        enum "gzip" {
          value 1;
          description "gzip";
        }
      }
      description
        "MDT grpc compression type";
    }

    typedef Mdt-dest-state-enum {
      type enumeration {
        enum "dest-not-active" {
          value 0;
          description "NA";
        }
        enum "dest-active" {
          value 1;
          description "Active";
        }
        enum "dest-asking-pause" {
          value 2;
          description "AskingPause";
        }
        enum "dest-paused" {
          value 3;
          description "Paused";
        }
        enum "dest-resuming" {
          value 4;
          description "Resuming";
        }
        enum "dest-channel-not-found" {
          value 5;
          description "ChannelNotFound";
        }
      }
      description "Destination state";
    }

    typedef Mdt-transport-enum {
      type enumeration {
        enum "not-set" {
          value 0;
          description "PROTOCOL NOT SET";
        }
        enum "grpc" {
          value 1;
          description "GRPC";
        }
        enum "tcp" {
          value 2;
          description "TCP";
        }
        enum "udp" {
          value 3;
          description "UDP";
        }
        enum "dialin" {
          value 6;
          description "DIALIN";
        }
      }
      description "MDT Transport";
    }

    typedef Mdt-encoding-enum {
      type enumeration {
        enum "not-set" {
          value 0;
          description "ENCODING NOT SET";
        }
        enum "gpb" {
          value 2;
          description "GPB";
        }
        enum "self-describing-gpb" {
          value 3;
          description "SELF DESCRIBING GPB";
        }
        enum "json" {
          value 4;
          description "JSON";
        }
        enum "gnmi-proto" {
          value 7;
          description "GNMI PROTO";
        }
        enum "gnmi-json" {
          value 8;
          description "GNMI JSON";
        }
      }
      description "MDT Encoding";
    }

    typedef Mdt-in6-addr {
      type inet:ipv6-address;
      description "Mdt in6 addr";
    }

    typedef Mdt-ip {
      type enumeration {
        enum "ipv4" {
          value 1;
          description "IPv4";
        }
        enum "ipv6" {
          value 2;
          description "IPv6";
        }
      }
      description "IP Type";
    }

    grouping MDT-DESTINATION-CHAN-STATS {
      description
        "Per destination channel information";
      leaf encoding {
        type Mdt-encoding-enum;
        description
          "Destination group encoding";
      }

      leaf transport {
        type Mdt-transport-enum;
        description
          "Destination group transport";
      }

      leaf state {
        type Mdt-dest-state-enum;
        description
          "State of streaming on this destination";
      }

      leaf channel-id {
        type uint64;
        description
          "GRPC channel ID of this subscription and
         destination";
      }

      leaf in-use-buffers {
        type uint32;
        description
          "Number of buffers used by the channel";
      }

      leaf dropped-messages {
        type uint32;
        description
          "Number of messages dropped when channel becomes
         full";
      }
    }  // grouping MDT-DESTINATION-CHAN-STATS

    grouping MDT-DESTINATION-GROUP {
      description
        "Per Destination Group information";
      leaf id {
        type string;
        description "Destination Group name";
      }

      leaf configured {
        type uint32;
        description
          "Set if this is configured destination group";
      }

      list destination {
        description
          "list of destinations defined in this group";
        uses MDT-DESTINATION;
      }  // list destination
    }  // grouping MDT-DESTINATION-GROUP

    grouping MDT-SENSOR-GROUP {
      description
        "Per sensor group information";
      leaf id {
        type string;
        description "Sensor Group name";
      }

      leaf configured {
        type uint32;
        description
          "Set if this is configured sensor group";
      }

      list sensor-path {
        description
          "Array of information for sensor paths within
         sensor group";
        uses MDT-SENSOR-PATHS;
      }  // list sensor-path
    }  // grouping MDT-SENSOR-GROUP

    grouping MDT-SENSOR-PROFILE {
      description
        "Per sensor profile information";
      container sensor-group {
        description "sensor group";
        uses MDT-SENSOR-GROUP;
      }  // container sensor-group

      leaf sample-interval {
        type uint32;
        description
          "Sample interval for the sensor group (ms)";
      }

      leaf heartbeat-interval {
        type uint32;
        description
          "Heartbeat interval for the sensor group (s)";
      }

      leaf suppress-redundant {
        type boolean;
        description "Suppress Redundant";
      }
    }  // grouping MDT-SENSOR-PROFILE

    grouping MDT-SOURCE-INTERFACE {
      description
        "source interface information";
      leaf interface-name {
        type string;
        description "Source Interface Name";
      }

      leaf state {
        type boolean;
        description "interface state";
      }

      leaf ipv4-address {
        type inet:ipv4-address;
        description "IPV4 Address";
      }

      leaf ipv6-address {
        type Mdt-in6-addr;
        description "IPV6 Address";
      }

      leaf vrf-id {
        type uint32;
        description "Src Vrf Id";
      }
    }  // grouping MDT-SOURCE-INTERFACE

    grouping MDT-SUBSCRIPTION {
      description
        "Per subscription group information";
      container source-interface {
        description
          "configured source interface";
        uses MDT-SOURCE-INTERFACE;
      }  // container source-interface

      leaf id {
        type string;
        description
          "Collection Subscription name";
      }

      leaf state {
        type Mdt-subs-state-enum;
        description "Subscription state";
      }

      leaf source-qos-marking {
        type Mdt-source-qos-marking;
        description "DSCP";
      }

      list sensor-profile {
        description
          "List of sensor groups within a subscription";
        uses MDT-SENSOR-PROFILE;
      }  // list sensor-profile

      list destination-grp {
        description
          "Array of destinations within a subscription";
        uses MDT-DESTINATION-GROUP;
      }  // list destination-grp
    }  // grouping MDT-SUBSCRIPTION

    grouping MDT-SUBSCRIPTION-DETAILS {
      description
        "Per subscription group detailed information";
      container subscription {
        description "Subscription";
        uses MDT-SUBSCRIPTION;
      }  // container subscription

      list collection-group {
        description
          "List of collection groups active for this
         subscription";
        uses MDT-COLLECTION-GROUP;
      }  // list collection-group
    }  // grouping MDT-SUBSCRIPTION-DETAILS

    grouping MDT-COLLECTION-SYSDB-GROUP {
      description
        "Per collection group sysdb information";
      leaf path {
        type string;
        description "Sysdb Path";
      }

      leaf cadence {
        type uint64;
        description
          "Period of the collections (ms)";
      }

      leaf total-get-count {
        type uint64;
        description "Total number of gets";
      }

      leaf total-list-count {
        type uint64;
        description "Total number of lists";
      }

      leaf total-datalist-count {
        type uint64;
        description
          "Total number of datalists";
      }

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

      leaf total-get-bulk-count {
        type uint64;
        description
          "Total number of get bulk";
      }

      leaf total-item-count {
        type uint64;
        description
          "Total number of items retrived from sysdb";
      }

      leaf total-get-errors {
        type uint64;
        description
          "Total number of get errors";
      }

      leaf total-list-errors {
        type uint64;
        description
          "Total number of list errors";
      }

      leaf total-datalist-errors {
        type uint64;
        description
          "Total number of datalist errors";
      }

      leaf total-finddata-errors {
        type uint64;
        description
          "Total number of finddata errors";
      }

      leaf total-get-bulk-errors {
        type uint64;
        description
          "Total number of get bulk errors";
      }

      leaf total-encode-errors {
        type uint64;
        description
          "Total number of encode errors";
      }

      leaf total-encode-notready {
        type uint64;
        description
          "Total number of encode deferred";
      }

      leaf total-send-errors {
        type uint64;
        description
          "Total number of send errors";
      }

      leaf total-send-drops {
        type uint64;
        description
          "Total number of send channel full";
      }

      leaf total-sent-bytes {
        type uint64;
        units "byte";
        description
          "Total number of bytes sent";
      }

      leaf total-send-packets {
        type uint64;
        description
          "Total number of packets sent";
      }

      leaf total-send-bytes-dropped {
        type uint64;
        units "byte";
        description
          "Total number of send bytes dropped";
      }

      leaf total-collections {
        type uint64;
        description
          "Completed collections count";
      }

      leaf total-collections-missed {
        type uint64;
        description
          "Total number of collections missed";
      }

      leaf max-collection-time {
        type uint64;
        description
          "Maximum time for a collection (ms)";
      }

      leaf min-collection-time {
        type uint64;
        description
          "Minimum time for a collection (ms)";
      }

      leaf avg-collection-time {
        type uint64;
        description
          "Average time for a collection (ms)";
      }

      leaf collection-method {
        type uint64;
        description
          "Collection method in use";
      }

      leaf status {
        type Mdt-internal-path-status;
        description
          "Status of collection path";
      }

      leaf total-heartbeats-missed {
        type uint64;
        description
          "Total number of heartbeats missed";
      }

      leaf internal-keys {
        type string;
        description
          "Keys for the sensor path, if configured";
      }

      leaf filtered-item-count {
        type uint64;
        description
          "Count of number of items that got filtered";
      }
    }  // grouping MDT-COLLECTION-SYSDB-GROUP

    grouping MDT-SENSOR-PATHS {
      description "Sensor Path information";
      leaf path {
        type string;
        description "Sensor Path";
      }

      leaf state {
        type boolean;
        description
          "State, if sensor path is resolved or not";
      }

      leaf status-str {
        type string;
        description
          "Error str, if there are any errors resolving the
         sensor path";
      }

      leaf configured-keys {
        type string;
        description
          "Keys for the sensor path, if configured";
      }
    }  // grouping MDT-SENSOR-PATHS

    grouping MDT-COLLECTION-GROUP {
      description
        "Per collection group information";
      leaf id {
        type uint64;
        description "Collection Group id";
      }

      leaf cadence {
        type uint32;
        description
          "Period of the collections (ms)";
      }

      leaf total-collections {
        type uint32;
        description
          "Completed collections count";
      }

      leaf encoding {
        type Mdt-encoding-enum;
        description
          "Destination group encoding";
      }

      leaf last-collection-start-time {
        type uint64;
        description
          "Timestamp of the start of last collection";
      }

      leaf last-collection-end-time {
        type uint64;
        description
          "Timestamp of the end of last collection";
      }

      leaf max-collection-time {
        type uint32;
        description
          "Maximum time for a collection (ms)";
      }

      leaf min-collection-time {
        type uint32;
        description
          "Minimum time for a collection (ms)";
      }

      leaf min-total-time {
        type uint32;
        description
          "Minimum time for all processing (ms)";
      }

      leaf max-total-time {
        type uint32;
        description
          "Maximum time for all processing (ms)";
      }

      leaf avg-total-time {
        type uint32;
        description
          "Average time for all processing (ms)";
      }

      leaf total-other-errors {
        type uint32;
        description "Total number of errors";
      }

      leaf total-on-data-instances {
        type uint32;
        description
          "Total number of no data instances";
      }

      leaf total-not-ready {
        type uint32;
        description
          "Total number skipped (not ready)";
      }

      leaf total-send-errors {
        type uint32;
        description
          "Total number of send errors";
      }

      leaf total-send-drops {
        type uint32;
        description
          "Total number of send drops";
      }

      leaf strict-timer {
        type boolean;
        description
          "Set if strict timer is ON";
      }

      leaf heartbeat-interval {
        type uint32;
        description
          "Heartbeat interval (ms)";
      }

      leaf heartbeat-always {
        type boolean;
        description
          "Send heartbeat even if events have occurred
         within interval";
      }

      list collection-path {
        description
          "Array of information for sensor paths within
         collection group";
        uses MDT-SENSOR-PATHS;
      }  // list collection-path

      list internal-collection-group {
        description
          "Array of information for sysdb paths within
         collection group";
        uses MDT-COLLECTION-SYSDB-GROUP;
      }  // list internal-collection-group
    }  // grouping MDT-COLLECTION-GROUP

    grouping MDT-COLLECTION-DETAIL {
      description
        "Per Destination jobs information";
      leaf subscription-id {
        type uint64;
        description "Subscription ID";
      }

      leaf sysdb-path {
        type string;
        description
          "SysDB path of the sensor path";
      }

      leaf in-progress {
        type boolean;
        description
          "True if collection is in progress";
      }

      leaf create-time {
        type string;
        description
          "Collection request time, format 1985-04-12 23:20
         :50.254143 -0700";
      }

      leaf start-time {
        type string;
        description
          "Collection start time, format 1985-04-12 23:20
         :50.254143 -0700";
      }

      leaf completion-time {
        type string;
        description
          "Collection finish time, format 1985-04-12 23:20
         :50.254143 -0700";
      }

      leaf token-receive-time {
        type string;
        description
          "Last time when tokens were received, format
         1985-04-12 23:20:50.254143 -0700";
      }

      leaf last-packet-send-time {
        type string;
        description
          "Last time a packet was sent, format
         1985-04-12 23:20:50.254143 -0700";
      }
    }  // grouping MDT-COLLECTION-DETAIL

    grouping MDT-DESTINATION-IP-ADDRESS {
      description
        "MDT DESTINATION IP ADDRESS";
      leaf ip-type {
        type Mdt-ip;
        description "IPType";
      }

      leaf ipv4-address {
        when "../ip-type = 'ipv4'" {
          description "../IPType = 'IPV4'";
        }
        type inet:ipv4-address;
        description "IPV4 Address";
      }

      leaf ipv6-address {
        when "../ip-type = 'ipv6'" {
          description "../IPType = 'IPV6'";
        }
        type Mdt-in6-addr;
        description "IPV6 Address";
      }
    }  // grouping MDT-DESTINATION-IP-ADDRESS

    grouping MDT-DESTINATION {
      description
        "Per Destination information";
      container dest-ip-address {
        description "Destination IP Address";
        uses MDT-DESTINATION-IP-ADDRESS;
      }  // container dest-ip-address

      leaf id {
        type string;
        description "Destination Id";
      }

      leaf sub-id-str {
        type string;
        description "Sub Idstr";
      }

      leaf dest-port {
        type uint16;
        description
          "Destination Port number";
      }

      leaf encoding {
        type Mdt-encoding-enum;
        description
          "Destination group encoding";
      }

      leaf transport {
        type Mdt-transport-enum;
        description
          "Destination group transport";
      }

      leaf vrf {
        type string;
        description "Destination group vrf";
      }

      leaf vrf-id {
        type uint32;
        description
          "Destination group vrf id";
      }

      leaf state {
        type Mdt-dest-state-enum;
        description
          "State of streaming on this destination";
      }

      leaf udp-mtu {
        type uint32;
        description
          "UDP MTU if this destination is UDP";
      }

      leaf tls {
        type uint32;
        description
          "TLS connection to this destination";
      }

      leaf tls-host {
        type string;
        description
          "TLS Hostname of this destination";
      }

      leaf total-num-of-packets-sent {
        type uint64;
        description
          "Total number of packets sent for this
         destination";
      }

      leaf total-num-of-bytes-sent {
        type uint64;
        units "byte";
        description
          "Total number of bytes sent for this destination";
      }

      leaf last-collection-time {
        type uint64;
        description
          "Timestamp of the last collection";
      }

      leaf dscp {
        type uint32;
        description
          "DSCP setting for this destination";
      }

      leaf maximum-tokens {
        type uint32;
        description
          "Maximum number of tokens";
      }

      leaf token-processed-time {
        type string;
        description
          "Last token processed time, format 1985-04-12 23
         :20:50.521256 -0700";
      }

      leaf cadence-tokens {
        type uint32;
        description
          "Number of available cadence tokens";
      }

      leaf cadence-token-advertised-time {
        type string;
        description
          "Last cadence token advertisement time, format
         1985-04-12 23:20:50.254143 -0700";
      }

      leaf event-tokens {
        type uint32;
        description
          "Number of available event tokens";
      }

      leaf event-token-advertised-time {
        type string;
        description
          "Last event token advertisement time, format
         1985-04-12 23:20:50.254143 -0700";
      }

      leaf pending-queue-size {
        type uint32;
        description
          "Number of messages in pending queue";
      }

      leaf gnmi-sync-response-time {
        type string;
        description
          "GNMI initial synchronization message time,
         format            1985-04-12 23:20:50.254143
         -0700";
      }

      leaf pending-events {
        type uint32;
        description
          "Number of events pending to be processed";
      }

      leaf processed-events {
        type uint64;
        description
          "Number of events processed";
      }

      leaf collection-tokens {
        type uint32;
        description
          "Number of collection tokens";
      }

      leaf compression {
        type Mdt-compression;
        description
          "Compression algorithm in use";
      }

      list collection-detail {
        description
          "Collection details for this destination";
        uses MDT-COLLECTION-DETAIL;
      }  // list collection-detail
    }  // grouping MDT-DESTINATION

    grouping MDT-DESTINATION-DETAIL {
      description
        "Per Destination detail information";
      container destination {
        description "Destination";
        uses MDT-DESTINATION;
      }  // container destination

      list collection-group {
        description
          "List of collection groups for this destination
         group";
        uses MDT-COLLECTION-GROUP;
      }  // list collection-group
    }  // grouping MDT-DESTINATION-DETAIL

    grouping MDT-DESTINATION-GROUP-DETAIL {
      description
        "Per Destination Group detail information";
      leaf id {
        type string;
        description "Destination Group name";
      }

      leaf configured {
        type uint32;
        description
          "Set if this is configured destination group";
      }

      list destination {
        description
          "list of destinations defined in this group";
        uses MDT-DESTINATION-DETAIL;
      }  // list destination
    }  // grouping MDT-DESTINATION-GROUP-DETAIL
  }  // submodule Cisco-IOS-XR-telemetry-model-driven-oper-sub2