module Cisco-IOS-XE-mdt-cfg {

    yang-version 1;

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

    prefix mdt-cfg;

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

    revision "2020-11-01" {
      description
        "- Support for named receivers
       - Deprecated legacy receivers";
      reference
        "3.4.0";

    }

    revision "2020-03-01" {
      description
        "Support for Histogram transform operation";
      reference
        "3.3.0";

    }

    revision "2019-05-01" {
      description
        "- Support for new transform operations
       - Flattening the structure of new transform operations
       - Support for Division transform operation
       - Added semantic version";
      reference
        "3.2.0";

    }

    revision "2018-10-29" {
      description
        "Cleaned up spelling errors in descriptions.";
      reference
        "3.1.0";

    }

    revision "2018-08-24" {
      description
        "Make a receiver's protocol mandatory and
       remove its default.";
      reference
        "3.0.0";

    }

    revision "2018-02-12" {
      description
        "Transform support for Native stream.";
      reference
        "2.1.0";

    }

    revision "2018-02-07" {
      description "Fix top level name.";
      reference
        "2.0.0";

    }

    revision "2017-09-20" {
      description
        "TLS support for Native stream";
      reference
        "1.1.0";

    }

    revision "2017-03-02" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "3.4.0";
    cisco-semver:module-version "3.3.0";
    cisco-semver:module-version "3.2.0";
    cisco-semver:module-version "3.1.0";
    cisco-semver:module-version "3.0.0";
    cisco-semver:module-version "2.1.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.1.0";
    cisco-semver:module-version "1.0.0";

    typedef mdt-xfrm-attr-type {
      type enumeration {
        enum "mdt-xfrm-attr-none" {
          value 0;
          description
            "Indicates that no filter has been
           specified.";
        }
        enum "mandatory" {
          value 1;
          description
            "Indicates that mandatory filter is set.";
        }
        enum "primary" {
          value 2;
          description
            "Indicates that primary filter is set.";
        }
      }
      description
        "Types of subscription transform attribute type";
    }

    typedef mdt-xfrm-op-type {
      type enumeration {
        enum "sub-record" {
          value 0;
          description
            "Indicates that operation type is
           sub-record";
        }
        enum "delta" {
          value 1;
          description
            "Indicates that operation type is delta";
        }
      }
      description
        "Types of subscription transform operations.";
    }

    typedef mdt-xfrm-logic-op {
      type enumeration {
        enum "mdt-xfrm-lop-none" {
          value 0;
          description
            "Indicates that no logical operation
           is selected";
        }
        enum "and" {
          value 1;
          description
            "Indicates that logical operation
           is 'and' ";
        }
        enum "or" {
          value 2;
          description
            "Indicates that logical operation is 'or' ";
        }
      }
      description
        "Types of subscription transform
       logical operations.";
    }

    typedef mdt-xfrm-operator {
      type enumeration {
        enum "operator-none" {
          value 0;
          description "Default operator";
        }
        enum "eq" {
          value 1;
          description "Equal operator";
        }
        enum "ne" {
          value 2;
          description "Not equal operator";
        }
        enum "gt" {
          value 3;
          description
            "Greater than operator";
        }
        enum "ge" {
          value 4;
          description
            "Greater than or equal operator";
        }
        enum "lt" {
          value 5;
          description "Less than operator";
        }
        enum "le" {
          value 6;
          description
            "Less than or equal operator";
        }
      }
      description "Supported operator types";
    }

    typedef mdt-xfrm-condition-check-with {
      type enumeration {
        enum
          "condition-check-wth-argument-value" {
          value 0;
          description
            "Indicates that conditional check should happen with provided value";
        }
        enum
          "condition-check-wth-previous-value" {
          value 1;
          description
            "Indicates that conditional check should happen with
           previous value of the field";
        }
      }
      description
        "Specifies the kind of value
       this condition check should happen with.
       This way conditional operation can compare with either the
       user provided value or the previously cached value of
       the same field";
    }

    typedef mdt-xfrm-operation-type {
      type enumeration {
        enum "xfrm-oper-none" {
          value 0;
          description
            "Indicates operation has not been specified.";
        }
        enum "xfrm-oper-mean" {
          value 1;
          description
            "Mean of the cached values";
        }
        enum "xfrm-oper-mean-window" {
          value 2;
          description
            "Mean over a specified window";
        }
        enum "xfrm-oper-rate" {
          value 3;
          description
            "Rate of change in value";
        }
        enum "xfrm-oper-ewma" {
          value 4;
          description
            "Exponentially Weighted Moving Average";
        }
        enum "xfrm-oper-delta" {
          value 5;
          description
            "Delta with previously known value";
        }
        enum "xfrm-oper-div" {
          value 6;
          description "Division operation";
        }
        enum "xfrm-oper-div-of-delta" {
          value 7;
          description
            "Division operation is performed on Delta of field values";
        }
        enum "xfrm-oper-hist" {
          value 8;
          description
            "Histogram operation is performed over field values";
        }
      }
      description
        "Operation to be performed";
    }

    typedef mdt-xfrm-window-size-type {
      type enumeration {
        enum "time-based" {
          value 0;
          description "Time based windowing";
        }
        enum "count-based" {
          value 1;
          description
            "Count based windowing";
        }
      }
      description
        "Type of window size (eg. time, count based)";
    }

    typedef mdt-xfrm-window-segment-type {
      type enumeration {
        enum "sliding-window" {
          value 0;
          description "Sliding window";
        }
        enum "tumbling-window" {
          value 1;
          description "Tumbling window";
        }
      }
      description
        "Type of window segment (eg. sliding, tumbling etc)";
    }

    typedef mdt-operand-ref-type {
      type enumeration {
        enum "operand-ref-const" {
          value 0;
          description
            "Indicates that the operand is a constant";
        }
        enum "operand-ref-field" {
          value 1;
          description
            "Indicates that the operand is the value of the specified field";
        }
      }
      description
        "Type operand reference
       (eg whether it is constant, other field etc)";
    }

    typedef mdt-div-operand-role {
      type enumeration {
        enum "operand-role-dividend" {
          value 0;
          description
            "Indicates that the operand is a dividend";
        }
        enum "operand-role-divisor" {
          value 1;
          description
            "Indicates that the operand is a divisor";
        }
      }
      description
        "Role of operand in division operation";
    }

    typedef mdt-xfrm-alert-type {
      type enumeration {
        enum "noop" {
          value 0;
          description
            "No alert based operation";
        }
        enum "limit-threshold" {
          value 1;
          description
            "Limit threshold based alerting";
        }
      }
      description "Type of alert";
    }

    typedef mdt-xfrm-alert-size-type {
      type enumeration {
        enum "duration" {
          value 0;
          description "Time based alerting";
        }
        enum "frequency" {
          value 1;
          description "Count based alerting";
        }
      }
      description
        "Type of alerting (eg. time, count based)";
    }

    container mdt-config-data {
      description "MDT configuration data";
      list mdt-subscription {
        key "subscription-id";
        description "List of subscriptions";
        leaf subscription-id {
          type uint32 {
            range "0 .. 2147483647";
          }
          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

        list mdt-receivers {
          must
            "../base/rcvr-type = 'rcvr-type-unspecified'" {
            error-message
              "Legacy receivers are not allowed with rcvr-type";
            error-app-tag "must-violation";
          }
          must
            "(count(../mdt-receiver-names/mdt-receiver-name) = 0)" {
            error-message
              "Legacy receivers are not allowed with receiver name";
            error-app-tag "must-violation";
          }
          key "address port";
          status deprecated;
          description
            "Configuration of receivers of configured
subscriptions.
Use of this is deprecated. Use mdt-receiver-names instead.";
          leaf protocol {
            type string;
            mandatory true;
            description
              "Receiver transport protocol.";
          }

          leaf profile {
            type string;
            description
              "Name of protocol profile used by receiver.";
          }

          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

        container mdt-receiver-names {
          description
            "List of configured receiver names.";
          list mdt-receiver-name {
            must
              "(count(../../mdt-receivers) = 0)" {
              error-message
                "Named receivers are not allowed with legacy receiver";
              error-app-tag "must-violation";
            }
            key "name";
            description
              "A configured receiver of this subscription.
Refers to an entry in the global named receivers list indicated
by rcvr-type string of the parent subscription.
Receivers of this type cannot be used with the deprecated
mdt-receivers type.";
            leaf name {
              type string;
              description
                "The name of the receiver.
Is a key to an entry in the named receivers list indicated
by rcvr-type string of the parent subscription.";
            }
          }  // list mdt-receiver-name
        }  // container mdt-receiver-names
      }  // list mdt-subscription

      container mdt-named-protocol-rcvrs {
        description
          "List of configured named protocol receivers.";
        list mdt-named-protocol-rcvr {
          key "name";
          description
            "Configuration for receivers using a receiver type
           identified as 'protocol' in the subscription's
           rcvr-type field.";
          leaf name {
            type string;
            description
              "Name of the receiver";
          }

          leaf protocol {
            type mdt-common-defs:prot-rcvr-protocol;
            description
              "Name of the protocol";
          }

          leaf profile {
            type string;
            description
              "Optional profile used by the receiver.";
          }

          container host {
            description "Host type";
            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 "Host port";
          }
        }  // list mdt-named-protocol-rcvr
      }  // container mdt-named-protocol-rcvrs

      list mdt-xfrm {
        key "name";
        description
          "List of subscription transforms";
        leaf name {
          type string;
          description
            "Unique transform identifier.";
        }

        leaf fully-specify {
          type boolean;
          description
            "When fully-specify is set,
fully-specify field identifier is sent
in the response record along with field value";
        }

        list mdt-xfrm-input {
          key "table-name";
          description
            "Transform input information";
          leaf table-name {
            type string;
            description
              "Transform input URI table name";
          }

          leaf uri {
            type string;
            description
              "Transform input URI full-path";
          }

          list mdt-xfrm-input-field {
            key "field";
            description
              "Transform input URI table fields";
            leaf field {
              type string;
              description
                "Transform input URI table field name";
            }
          }  // list mdt-xfrm-input-field

          leaf join-key {
            type string;
            description
              "Transform input table join-key";
          }

          leaf attr-type {
            type mdt-xfrm-attr-type;
            description
              "Transform input table attribute type
e.g. table is mandatory for join record";
          }

          leaf lop {
            type mdt-xfrm-logic-op;
            description
              "Logical operation with next
input table event";
          }

          leaf key {
            type string;
            description
              "Transform input table key";
          }
        }  // list mdt-xfrm-input

        list mdt-xfrm-op {
          key "id";
          description
            "Transform operations information";
          leaf id {
            type uint32;
            description
              "Unique transform operation id";
          }

          list mdt-xfrm-op-filters {
            key "filter-id";
            description
              "Transform operation filters.
These are evaluated before performing
transform action (e.g. sub record)
on the response record";
            leaf filter-id {
              type uint32;
              description
                "filters will be evaluated in sequence based
on filter ID";
            }

            leaf field {
              type string;
              description
                "Transform operation filter field name";
            }

            container op-event {
              description
                "Transform operation event flag (e.g. onchange)";
              leaf onchange {
                type boolean;
                description
                  "Indicates that onchange filter is set.";
              }
            }  // container op-event

            leaf lop {
              type mdt-xfrm-logic-op;
              description
                "logical operation with condition";
            }

            container condition {
              description
                "Per field condition (e.g. f1 eq 'name')";
              leaf operator {
                type mdt-xfrm-operator;
                description
                  "Type of operator";
              }

              leaf value {
                type string;
                description
                  "Field value to operate on";
              }

              leaf check-with {
                type mdt-xfrm-condition-check-with;
                description
                  "Specifies the kind of value
this condition check should happen with.
This way conditional operation can compare with either the
user provided value or the previously cached value of
the same field";
              }
            }  // container condition

            leaf next-lop {
              type mdt-xfrm-logic-op;
              description
                "logical operation with next filter condition";
            }

            choice operation-type-choice {
              default "xfrm-oper-none";
              description
                "Operation to be performed on input value";
              case xfrm-oper-none {
                description
                  "Indicates operation has not been specified. Value will be passed as-is";
                leaf operation-no-op {
                  type boolean;
                  default "false";
                  description
                    "Indicates operation has not been specified. Value will be passed as-is";
                }
              }  // case xfrm-oper-none

              case xfrm-oper-mean {
                description
                  "Mean of the cached values";
                leaf operation-mean {
                  type empty;
                  description
                    "Mean of the cached values";
                }
              }  // case xfrm-oper-mean

              case xfrm-oper-mean-window {
                description
                  "Mean over a specified window";
                container operation-mean-window {
                  description
                    "Data specifying Window parameters";
                  leaf window-size-type {
                    type mdt-xfrm-window-size-type;
                    description
                      "Type of window size (eg. time, count based)";
                  }

                  leaf window-size {
                    type uint32;
                    units "centiseconds";
                    description
                      "Window duration in case of time-based. Count in case of count-based";
                  }

                  leaf window-segment-type {
                    type mdt-xfrm-window-segment-type;
                    description
                      "Type of window segment (eg. sliding, tumbling etc)";
                  }
                }  // container operation-mean-window
              }  // case xfrm-oper-mean-window

              case xfrm-oper-rate {
                description
                  "Rate of change in value";
                leaf operation-rate {
                  type empty;
                  description
                    "Rate of change in value";
                }
              }  // case xfrm-oper-rate

              case xfrm-oper-ewma {
                description
                  "Exponentially Weighted Moving Average";
                container operation-ewma {
                  description
                    "Data specifying Exponentially Weighted Moving Average parameters";
                  leaf lambda {
                    type string;
                    description
                      "Lambda (weight factor) used in Exponentially Weighted Moving Average calculation";
                  }
                }  // container operation-ewma
              }  // case xfrm-oper-ewma

              case xfrm-oper-delta {
                description
                  "Delta with previously known value";
                leaf operation-delta {
                  type empty;
                  description
                    "Delta with previously known value";
                }
              }  // case xfrm-oper-delta

              case xfrm-oper-div {
                description
                  "Division operation";
                container operation-div {
                  description
                    "Data specifying Division parameters";
                  leaf operand-ref-type {
                    type mdt-operand-ref-type;
                    description
                      "Specify whether the operand specified is a constant
or a filed. If it is field, it's value shall be used
in division operation";
                  }

                  leaf operand-role {
                    type mdt-div-operand-role;
                    description
                      "Role of operand in division operation";
                  }

                  leaf operand {
                    type string;
                    description
                      "Operand value to be used in division operation. It can be
either a constant or name of another field";
                  }
                }  // container operation-div
              }  // case xfrm-oper-div

              case xfrm-oper-div-of-delta {
                description
                  "Division operation is performed on Delta of field values";
                container operation-div-of-delta {
                  description
                    "Data specifying Division of Delta parameters";
                  leaf operand-ref-type {
                    type mdt-operand-ref-type;
                    description
                      "Specify whether the operand specified is a constant
or a filed. If it is field, it's value shall be used
in division operation";
                  }

                  leaf operand-role {
                    type mdt-div-operand-role;
                    description
                      "Role of operand in division operation";
                  }

                  leaf operand {
                    type string;
                    description
                      "Operand value to be used in division operation. It can be
either a constant or name of another field";
                  }
                }  // container operation-div-of-delta
              }  // case xfrm-oper-div-of-delta
            }  // choice operation-type-choice
          }  // list mdt-xfrm-op-filters

          list mdt-xfrm-op-fields {
            key "field-id";
            description
              "Transform operation fields.
Default operation is sub record.
It is performed on each field";
            leaf field-id {
              type uint32;
              description
                "Transform operation response field-id, part of response record.
It is used to uniquely identify response record field";
            }

            leaf field {
              type string;
              description
                "Subscription transform field name on
which transform operation is performed";
            }

            leaf op-type {
              type mdt-xfrm-op-type;
              description
                "Subscription transform operation type";
            }

            leaf name {
              type string;
              description
                "Name of the field to be returned in output";
            }

            choice operation-type-choice {
              default "xfrm-oper-none";
              description
                "Operation to be performed on field before output";
              case xfrm-oper-none {
                description
                  "Indicates operation has not been specified. Value will be passed as-is";
                leaf operation-no-op {
                  type boolean;
                  default "false";
                  description
                    "Indicates operation has not been specified. Value will be passed as-is";
                }
              }  // case xfrm-oper-none

              case xfrm-oper-mean {
                description
                  "Mean of the cached values";
                leaf operation-mean {
                  type empty;
                  description
                    "Mean of the cached values";
                }
              }  // case xfrm-oper-mean

              case xfrm-oper-mean-window {
                description
                  "Mean over a specified window";
                container operation-mean-window {
                  description
                    "Data specifying Window parameters";
                  leaf window-size-type {
                    type mdt-xfrm-window-size-type;
                    description
                      "Type of window size (eg. time, count based)";
                  }

                  leaf window-size {
                    type uint32;
                    units "centiseconds";
                    description
                      "Window duration in case of time-based. Count in case of count-based";
                  }

                  leaf window-segment-type {
                    type mdt-xfrm-window-segment-type;
                    description
                      "Type of window segment (eg. sliding, tumbling etc)";
                  }
                }  // container operation-mean-window
              }  // case xfrm-oper-mean-window

              case xfrm-oper-rate {
                description
                  "Rate of change in value";
                leaf operation-rate {
                  type empty;
                  description
                    "Rate of change in value";
                }
              }  // case xfrm-oper-rate

              case xfrm-oper-ewma {
                description
                  "Exponentially Weighted Moving Average";
                container operation-ewma {
                  description
                    "Data specifying Exponentially Weighted Moving Average parameters";
                  leaf lambda {
                    type string;
                    description
                      "Lambda (weight factor) used in Exponentially Weighted Moving Average calculation";
                  }
                }  // container operation-ewma
              }  // case xfrm-oper-ewma

              case xfrm-oper-delta {
                description
                  "Delta with previously known value";
                leaf operation-delta {
                  type empty;
                  description
                    "Delta with previously known value";
                }
              }  // case xfrm-oper-delta

              case xfrm-oper-div {
                description
                  "Division operation";
                container operation-div {
                  description
                    "Data specifying Division parameters";
                  leaf operand-ref-type {
                    type mdt-operand-ref-type;
                    description
                      "Specify whether the operand specified is a constant
or a filed. If it is field, it's value shall be used
in division operation";
                  }

                  leaf operand-role {
                    type mdt-div-operand-role;
                    description
                      "Role of operand in division operation";
                  }

                  leaf operand {
                    type string;
                    description
                      "Operand value to be used in division operation. It can be
either a constant or name of another field";
                  }
                }  // container operation-div
              }  // case xfrm-oper-div

              case xfrm-oper-div-of-delta {
                description
                  "Division operation is performed on Delta of field values";
                container operation-div-of-delta {
                  description
                    "Data specifying Division of Delta parameters";
                  leaf operand-ref-type {
                    type mdt-operand-ref-type;
                    description
                      "Specify whether the operand specified is a constant
or a filed. If it is field, it's value shall be used
in division operation";
                  }

                  leaf operand-role {
                    type mdt-div-operand-role;
                    description
                      "Role of operand in division operation";
                  }

                  leaf operand {
                    type string;
                    description
                      "Operand value to be used in division operation. It can be
either a constant or name of another field";
                  }
                }  // container operation-div-of-delta
              }  // case xfrm-oper-div-of-delta

              case xfrm-oper-hist {
                description
                  "Histogram operation is performed field values";
                container operation-hist {
                  description
                    "Data specifying Histogram parameters";
                  leaf bin-size {
                    type uint64;
                    description
                      "Specify the bin size";
                  }

                  leaf min {
                    type uint64;
                    description
                      "Specify the min value";
                  }

                  leaf max {
                    type uint64;
                    description
                      "Specify the max value";
                  }
                }  // container operation-hist
              }  // case xfrm-oper-hist
            }  // choice operation-type-choice
          }  // list mdt-xfrm-op-fields

          container alert-data {
            description
              "Transform alert data.
It sets the alerting mechanism";
            leaf alert-type {
              type mdt-xfrm-alert-type;
              description "Type of alert";
            }

            leaf alert-size-type {
              type mdt-xfrm-alert-size-type;
              description
                "Window duration in case of time-based. Count in case of count-based";
            }

            leaf alert-size {
              type uint32;
              units "centiseconds";
              description
                "Window duration in case of time-based. Count in case of count-based";
            }
          }  // container alert-data
        }  // list mdt-xfrm-op
      }  // list mdt-xfrm
    }  // container mdt-config-data
  }  // module Cisco-IOS-XE-mdt-cfg