module Cisco-IOS-XE-mdt-oper-v2 {

    yang-version 1;

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

    prefix mdt-oper-v2;

    import Cisco-IOS-XE-mdt-common-defs {
      prefix mdt-common-defs;
    }
    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 operational data of streaming telemetry.
     Copyright (c) 2016-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-07-01" {
      description
        "- Add subchannel requested receiver state";
      reference
        "1.2.0";

    }

    revision "2020-11-01" {
      description
        "- Add host and receiver parameter types.
       - Add protocol connection parameters and new connection type";
      reference
        "1.1.0";

    }

    revision "2020-07-01" {
      description "Initial revision";
      reference
        "1.0.0";

    }

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

    typedef mdt-sub-type {
      type enumeration {
        enum "sub-type-dynamic" {
          value 1;
          description
            "Dynamic subscriptions
           -do not survive reboot
           -existence tied to connection they are created on
           -send updates only to peer that creates them";
        }
        enum "sub-type-static" {
          value 2;
          description
            "Static subscriptions
           -created, (modified), and deleted by management operations
           -survive reboot
           -receivers are configured ";
        }
        enum "sub-type-permanent" {
          value 3;
          description
            "Permanent subscriptions
           -created during system startup, can not be modified";
        }
      }
      description "Subscription types";
    }

    typedef mdt-sub-state {
      type enumeration {
        enum "sub-state-valid" {
          value 0;
          description
            "The subscription is valid and may be sending updates.";
        }
        enum "sub-state-suspended" {
          value 1;
          description
            "The subscription has been suspended and is not
           sending notifications even if there are updates.";
        }
        enum "sub-state-terminated" {
          value 2;
          description
            "The subscription is terminated. This state is valid
           only for static subscriptions.";
        }
        enum "sub-state-invalid" {
          value 3;
          description
            "The subscription is invalid. This state is valid
           only for static subscriptions.";
        }
        enum "sub-state-deleted" {
          value 4;
          description
            "The subscription is in the process of being deleted from the
           system. This state is valid only for static subscriptions.";
        }
      }
      description "Subscription states";
    }

    typedef mdt-named-rcvr-state {
      type enumeration {
        enum "named-rcvr-state-invalid" {
          value 1;
          description
            "The receiver configuration is invalid and
           cannot be used.";
        }
        enum "named-rcvr-state-valid" {
          value 2;
          description
            "The receiver configuration is valid";
        }
      }
      description "Named receiver states.";
    }

    typedef mdt-receiver-state {
      type enumeration {
        enum "rcvr-state-invalid" {
          value 1;
          description
            "The receiver configuration is invalid and
           cannot be used.";
        }
        enum "rcvr-state-disconnected" {
          value 2;
          description
            "The receiver is disconnected and there is no
           attempt being made to connect to it.";
        }
        enum "rcvr-state-connecting" {
          value 3;
          description
            "An attempt is being made to connect to the receiver.";
        }
        enum "rcvr-state-connected" {
          value 4;
          description
            "The receiver is connected, and update notifications
           are being sent to the receiver when they occur";
        }
        enum "rcvr-state-disconnecting" {
          value 5;
          description
            "The receiver is in the process of being disconnected.";
        }
        enum "rcvr-state-resolving" {
          value 6;
          description
            "The receiver is determining connection parameters";
        }
        enum
          "rcvr-state-transport-requested" {
          value 7;
          description
            "A request has been made to setup required transport
           using resolved connection parameters.";
        }
        enum
          "rcvr-state-subchannel-requested" {
          value 8;
          description
            "A request has been made to setup the
           required subchannel to the receiver.";
        }
      }
      description "Receiver states.";
    }

    typedef mdt-connection-type {
      type enumeration {
        enum "conn-type-protocol" {
          value 0;
          status deprecated;
          description
            "The connection type is protocol (deprecated).
           Use con-type-protocol instead";
        }
        enum "con-type-protocol" {
          value 1;
          description
            "The connection type is protocol";
        }
      }
      description "Connection Types";
    }

    typedef mdt-con-state {
      type enumeration {
        enum "con-state-active" {
          value 0;
          description
            "The connection is active and usable.";
        }
        enum "con-state-connecting" {
          value 1;
          description
            "An attempt is being made to set the connection up.";
        }
        enum "con-state-pending" {
          value 2;
          description
            "The connection is down, but between connection
           attempts. It is in this state, for example, during
           the idle time between retries. No longer used - use
           con-state-connecting instead.";
        }
        enum "con-state-disconnecting" {
          value 3;
          description
            "The connection is the process of being disconnected.";
        }
      }
      description "Connection states.";
    }

    container mdt-oper-v2-data {
      config false;
      description "MDT operational data.";
      container mdt-streams {
        description
          "MDT streams table. The list of supported streams.";
        leaf-list stream {
          type string;
          ordered-by user;
          description
            "Name of a supported stream.";
        }
      }  // container mdt-streams

      list mdt-subscriptions {
        key "subscription-id";
        description
          "MDT subscription operational data.";
        leaf subscription-id {
          type uint32;
          description
            "Unique subscription identifier.";
        }

        container base {
          description
            "Common subscription information.";
          leaf stream {
            type string;
            default "NETCONF";
            description
              "The name of the event stream being subscribed to";
          }

          leaf encoding {
            type string;
            default "encode-xml";
            description
              "Update notification encoding";
          }

          leaf source-vrf {
            type string;
            description
              "Network instance name for the VRF";
          }

          leaf source-address {
            type inet:ip-address;
            description
              "The source address for the notifications";
          }

          leaf rcvr-type {
            type mdt-common-defs:mdt-rcvr-type;
            default "rcvr-type-unspecified";
            description
              "Receiver type used by all named receivers of this subscription.
It is used to determine the specific receiver-type global list
that defines the receiver. It may specify a related group of
receivers without identifying a specific receiver-type.
Cannot be used with the deprecated receiver configuration.";
          }

          choice update-trigger-choice {
            default "sub-upd-trig-none";
            description
              "Update trigger of the subscription";
            case sub-upd-trig-none {
              description
                "Indicates trigger has not been specified";
              leaf no-trigger {
                type uint32;
                default "0";
                description
                  "Placeholder for unset value";
              }
            }  // case sub-upd-trig-none

            case sub-upd-trig-periodic {
              description
                "Subscription is triggered on a periodic basis";
              leaf period {
                type uint32;
                units "centiseconds";
                mandatory true;
                description
                  "Period of update notifications in hundredths
of a second";
              }
            }  // case sub-upd-trig-periodic

            case sub-upd-trig-on-change {
              description
                "Subscription is triggered when a value changes";
              leaf no-synch-on-start {
                type boolean;
                description
                  "If true, there is no initial update notification
with the current value of all the data.
NOT CURRENTLY SUPPORTED. If specified, must
be false";
              }
            }  // case sub-upd-trig-on-change
          }  // choice update-trigger-choice

          choice filter-type-choice {
            default "sub-filter-type-none";
            description
              "The type of filter chosen to select the events or the data
for the update notification";
            case sub-filter-type-none {
              description
                "Indicates that no filter has been specified";
              leaf no-filter {
                type uint32;
                default "0";
                description
                  "Placeholder for unset value";
              }
            }  // case sub-filter-type-none

            case sub-filter-type-xpath {
              description
                "Xpath defining the data items of interest.
A limited set of the Xpath 1.0 expressions is
supported";
              leaf xpath {
                type string;
                description
                  "XPath expression describing the set of objects
wanted as part of the subscription";
              }
            }  // case sub-filter-type-xpath

            case sub-filter-type-tdl-uri {
              description
                "TDL-URI defining the data items of interest";
              leaf tdl-uri {
                type string;
                description
                  "TDL-URI expression describing the set of objects
wanted as part of the subscription";
              }
            }  // case sub-filter-type-tdl-uri
            leaf transform-name {
              type string;
              description
                "Transform name is the reference to
tdl transform scheme";
            }

            case sub-filter-type-nested-uri {
              description
                "NESTED-URI defining the data items of interest";
              leaf nested-uri {
                type string;
                description
                  "TDL-URI-Recursive expression describing the set of objects
wanted as part of the subscription";
              }
            }  // case sub-filter-type-nested-uri
          }  // choice filter-type-choice
        }  // container base

        leaf type {
          type mdt-sub-type;
          description "Subscription type.";
        }

        leaf state {
          type mdt-sub-state;
          description "Subscription state.";
        }

        leaf state-explanation {
          type string;
          description
            "Comments related to subscription state.";
        }

        list mdt-receivers {
          key "address port";
          description
            "List of MDT receivers.";
          leaf protocol {
            type string;
            description
              "Receiver transport protocol.";
          }

          leaf state {
            type mdt-receiver-state;
            description "Receiver state.";
          }

          leaf state-explanation {
            type string;
            description
              "Comments related to receiver state.";
          }

          leaf profile {
            type string;
            description
              "Receiver's protocol profile name.";
          }

          leaf last-state-change-time {
            type yang:date-and-time;
            description
              "Time of last state change of this receiver.";
          }

          leaf con-index {
            type uint16;
            description
              "Receiver connection index";
          }

          leaf address {
            type inet:ip-address;
            mandatory true;
            description
              "IP address of the receiver";
          }

          leaf port {
            type uint16;
            mandatory true;
            description
              "Network port of the receiver";
          }
        }  // list mdt-receivers

        leaf last-state-change-time {
          type yang:date-and-time;
          description
            "Time of last state change of this subscription.";
        }

        list mdt-receiver-names {
          key "name";
          description
            "List of named receivers of this subscription.";
          leaf name {
            type string;
            description "The receiver name.";
          }

          leaf con-index {
            type uint16;
            description
              "Index into connections table of the connection being used by this
receiver.
Note that it's possible for a receiver with the same name being
used by a different subscription to use a different connection.";
          }

          leaf state {
            type mdt-receiver-state;
            description
              "Receiver state with respect to the parent subscription.";
          }

          leaf state-descr {
            when
              "(../state != 'rcvr-state-connected')";
            type string;
            description
              "Description related to receiver state.";
          }

          leaf last-state-change-time {
            type yang:date-and-time;
            description
              "Time of last state change of this receiver.";
          }
        }  // list mdt-receiver-names
      }  // list mdt-subscriptions

      list mdt-named-receivers {
        key "name";
        description
          "MDT named receiver operational data.";
        leaf name {
          type string;
          description
            "The name of the receiver.";
        }

        leaf profile {
          type string;
          description
            "The profile, if any, used by the receiver.";
        }

        container params {
          description
            "Parameters common to all receivers.";
          choice type-choice {
            default "rcvr-type-unspecified";
            description
              "The type specific parameters";
            case rcvr-type-unspecified {
              description
                "Receiver type is not specified";
              leaf unset {
                type empty;
                description
                  "An unspecified receiver type";
              }
            }  // case rcvr-type-unspecified

            case rcvr-type-protocol {
              description
                "Indicates a protocol based receiver";
              leaf protocol {
                type mdt-common-defs:prot-rcvr-protocol;
                default "prot-rcvr-unspec";
                description
                  "Name of the protocol";
              }

              container host {
                description
                  "Network host identity of the receiver";
                choice type-choice {
                  default
                    "host-type-unspecified";
                  description
                    "How the network host is identified";
                  case host-type-unspecified {
                    description
                      "Host type is not specified";
                    leaf unspecified {
                      type empty;
                      description
                        "An unspecified host type";
                    }
                  }  // case host-type-unspecified

                  case host-type-ip-addr {
                    description
                      "Host is specified using an IP address";
                    leaf address {
                      type inet:ip-address;
                      description
                        "IP address of the host";
                    }
                  }  // case host-type-ip-addr

                  case host-type-hostname {
                    description
                      "Host is specified using hostname";
                    leaf hostname {
                      type string;
                      description
                        "Host name";
                    }
                  }  // case host-type-hostname
                }  // choice type-choice
              }  // container host

              leaf port {
                type uint16;
                description
                  "Port number of the receiver";
              }
            }  // case rcvr-type-protocol
          }  // choice type-choice
        }  // container params

        leaf state {
          type mdt-named-rcvr-state;
          description
            "Named receiver state.";
        }

        leaf state-descr {
          when
            "(../state != 'named-rcvr-state-valid')";
          type string;
          description
            "Description related to receiver state.";
        }

        leaf last-state-change-time {
          type yang:date-and-time;
          description
            "Time of last state change of this receiver.";
        }
      }  // list mdt-named-receivers

      list mdt-connections {
        key "index";
        description
          "MDT subscription connection operational data.";
        leaf index {
          type uint16;
          description
            "Connection Tables Index";
        }

        container conn-id {
          description
            "Connection Type Index";
          choice con-type-choice {
            description
              "Type of Connection Type Choice";
            container con-params {
              description
                "Connection parameters";
              leaf address {
                type inet:ip-address;
                description "address";
              }

              leaf port {
                type uint16;
                description
                  "Connection port";
              }

              leaf vrf-table-id {
                type uint32;
                description "VRF table id";
              }

              leaf source-address {
                type inet:ip-address;
                description "source address";
              }
            }  // container con-params
          }  // choice con-type-choice

          choice type-choice {
            status deprecated;
            description
              "Type of Connection Type Choice";
            case conn-type-protocol {
              status deprecated;
              leaf address {
                type inet:ip-address;
                description "address";
              }

              leaf port {
                type uint16;
                description
                  "Connection port";
              }

              leaf vrf-table-id {
                type uint32;
                description "VRF table id";
              }

              leaf source-address {
                type inet:ip-address;
                description "source address";
              }
            }  // case conn-type-protocol
          }  // choice type-choice
        }  // container conn-id

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

        leaf state {
          type mdt-con-state;
          description "Connection state.";
        }

        leaf last-state-change-time {
          type yang:date-and-time;
          description
            "Time of last state change of this connection.";
        }
      }  // list mdt-connections
    }  // container mdt-oper-v2-data
  }  // module Cisco-IOS-XE-mdt-oper-v2