module Cisco-IOS-XE-tunnel-oper {

    yang-version 1;

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

    prefix ios-tunnel-oper;

    import Cisco-IOS-XE-event-history-types {
      prefix event-history-types;
    }
    import Cisco-IOS-XE-tunnel-types {
      prefix tunnel-types;
    }
    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
     Tunnel domains and interfaces.
     Copyright (c) 2018-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-07-01" {
      description
        "Deprecated EoGRE specific content. It is now moved to Cisco-IOS-XE-eogre-tunnel-oper namespace";
      reference
        "1.2.0";

    }

    revision "2019-05-01" {
      description "Added semantic version";
      reference
        "1.1.0";

    }

    revision "2018-11-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";

    container tunnel-oper-data {
      config false;
      description
        "Top-level container for tunnel operational data";
      list tunnel-domain {
        key "name type";
        status deprecated;
        description
          "List of tunnel domains, keyed by domain name and type";
        leaf name {
          type string;
          description "Domain Name";
        }

        leaf type {
          type tunnel-types:tunnel-domain-mode;
          description "Tunnel Type";
        }

        container cfg {
          description "Domain Configuration";
          leaf primary-tunnel-name {
            type string;
            description "Primary tunnel";
          }

          leaf secondary-tunnel-name {
            type string;
            description "Secondary tunnel";
          }

          leaf redundancy-model {
            type tunnel-types:tunnel-redundancy-model;
            description "Redundancy model";
          }

          leaf enable {
            type boolean;
            description
              "Whether it is enabled";
          }
        }  // container cfg

        leaf active-tunnel-name {
          type string;
          description "Active tunnel name";
        }

        container history {
          description "Event history";
          list event-history {
            description "Event history";
            leaf event {
              type uint32;
              description "event";
            }

            leaf state {
              type uint32;
              description "state";
            }

            leaf context {
              type uint32;
              description
                "Additional context value that may be occasionally
used";
            }

            leaf context-str {
              type string;
              description
                "Additional free-form context";
            }

            leaf current-rc {
              type uint32;
              description
                "Return code of the last operation to store";
            }

            leaf count {
              type uint32;
              description
                "Counter of number of occurrences of this event";
            }

            leaf sticky {
              type boolean;
              description
                "Represent whether the event is sticky or not";
            }

            leaf timestamp {
              type yang:date-and-time;
              description
                "Timestamp when the event is recorded";
            }
          }  // list event-history
        }  // container history
      }  // list tunnel-domain

      list tunnel-intf {
        key "name type";
        status deprecated;
        description
          "List of tunnel interfaces";
        leaf name {
          type string;
          description "Interface key name";
        }

        leaf type {
          type tunnel-types:tunnel-domain-mode;
          description "Interface key type";
        }

        leaf gateway-address {
          type inet:ip-address;
          description "Gateway IP address";
        }

        leaf admin-status {
          type tunnel-types:tunnel-intf-status;
          description
            "Administrative status";
        }

        leaf status {
          type tunnel-types:tunnel-intf-status;
          description
            "Tunnel operational status";
        }

        leaf up-timestamp {
          type yang:date-and-time;
          description
            "Last time this gateway went up";
        }

        leaf mtu {
          type uint32;
          description
            "Maximum transmission unit";
        }

        container stats {
          description "Tunnel Statistics";
          leaf flap-count {
            type uint32;
            description
              "Tunnel flap (up/down) count";
          }

          leaf total-rx-bytes {
            type uint64;
            description
              "Total received bytes";
          }

          leaf total-tx-bytes {
            type uint64;
            description
              "Total transmitted bytes";
          }

          leaf total-rx-pkts {
            type uint64;
            description
              "Total received packets";
          }

          leaf total-tx-pkts {
            type uint64;
            description
              "Total transmitted packets";
          }

          leaf client-count {
            type uint32;
            description
              "Number of clients in this tunnel";
          }

          leaf up-time {
            type uint32;
            description
              "How long this tunnel has been up";
          }

          leaf keepalive-tx {
            type uint64;
            description
              "Number of transmitted keepalives in last window";
          }

          leaf keepalive-rx {
            type uint64;
            description
              "Number of received keepalives in last window";
          }

          leaf keepalive-windows {
            type uint32;
            description "Keepalive windows";
          }

          leaf keepalive-dropped {
            type uint32;
            description
              "Number of dropped keepalives in last window";
          }

          leaf total-keepalive-tx {
            type uint64;
            description
              "Number of transmitted keepalives";
          }

          leaf total-keepalive-rx {
            type uint64;
            description
              "Number of received keepalives";
          }
        }  // container stats

        leaf source-interface {
          type string;
          description "Source Interface";
        }

        leaf source-address {
          type inet:ip-address;
          description "Source IP Address";
        }

        container history {
          description
            "Event history for this gateway";
          list event-history {
            description "Event history";
            leaf event {
              type uint32;
              description "event";
            }

            leaf state {
              type uint32;
              description "state";
            }

            leaf context {
              type uint32;
              description
                "Additional context value that may be occasionally
used";
            }

            leaf context-str {
              type string;
              description
                "Additional free-form context";
            }

            leaf current-rc {
              type uint32;
              description
                "Return code of the last operation to store";
            }

            leaf count {
              type uint32;
              description
                "Counter of number of occurrences of this event";
            }

            leaf sticky {
              type boolean;
              description
                "Represent whether the event is sticky or not";
            }

            leaf timestamp {
              type yang:date-and-time;
              description
                "Timestamp when the event is recorded";
            }
          }  // list event-history
        }  // container history

        leaf intf-type {
          type tunnel-types:tunnel-intf-mode;
          description
            "Tunnel interface type";
        }
      }  // list tunnel-intf

      list tunnel-if {
        key "name";
        description
          "List of tunnel interfaces";
        leaf name {
          type string;
          description
            "The name of the Tunnel interface.";
        }

        leaf mode {
          type tunnel-types:tunnel-intf-mode;
          description
            "The mode of the Tunnel interface.";
        }

        leaf intf-ipv4 {
          type inet:ipv4-address;
          description
            "IPv4 address configured on interface.";
        }

        leaf-list intf-ipv6 {
          type inet:ipv6-address;
          ordered-by user;
          description
            "A list of the IPv6 addresses associated with the interface.
This contains all the IPv6 addresses, including the link local
addresses, assigned to the interface";
        }

        leaf intf-vrf {
          type string;
          description
            "VRF to which this interface belongs to. If the
interface is not in a VRF then it is 'Global'.";
        }

        leaf transport-vrf {
          type string;
          description
            "Transport VRF. If this
is not mentioned, then it is 'Global'";
        }

        leaf admin-status {
          type tunnel-types:tunnel-intf-status;
          description
            "Administrative status";
        }

        leaf status {
          type tunnel-types:tunnel-intf-status;
          description
            "Tunnel interface operational status";
        }

        leaf src-if {
          type string;
          description "Source Interface";
        }

        leaf src-addr {
          type inet:ip-address;
          description
            "Tunnel Source IP Address";
        }

        leaf dst-addr {
          type inet:ip-address;
          description
            "Tunnel Destination IP Address";
        }

        leaf src-port {
          type uint16;
          description "Tunnel Source Port";
        }

        leaf dst-port {
          type uint16;
          description
            "Tunnel Destination Port";
        }

        leaf tunnel-key {
          type uint32;
          description
            "Tunnel security or selector key";
        }

        leaf mtu {
          type uint32;
          description
            "Maximum transmission unit";
        }

        leaf ip-mtu {
          type uint32;
          description
            "IP Maximum transmission unit";
        }

        leaf transport-mtu {
          type uint32;
          description
            "Tunnel transport maximum transmission unit";
        }

        leaf tx-bandwidth {
          type uint32;
          units "kbps";
          description
            "Tunnel transmit bandwidth";
        }

        leaf rx-bandwidth {
          type uint32;
          units "kbps";
          description
            "Tunnel receive bandwidth";
        }

        container stats {
          description
            "Tunnel interface Statistics";
          leaf in-octets {
            type uint64;
            description
              "The total number of octets received on the interface,
including framing characters.";
          }

          leaf in-unicast-pkts {
            type uint64;
            description
              "The total number of unicast packets received on the
interface.";
          }

          leaf in-broadcast-pkts {
            type uint64;
            description
              "The total number of broadcast packets received on the
interface.";
          }

          leaf in-multicast-pkts {
            type uint64;
            description
              "The total number of multicast packets received on the
interface.";
          }

          leaf in-discards {
            type uint64;
            description
              "The number of inbound packets that were chosen to be
discarded even though no errors.";
          }

          leaf in-errors {
            type uint64;
            description
              "The number of inbound packets that contained errors
preventing them from being deliverable to a higher-layer
protocol.";
          }

          leaf out-octets {
            type uint64;
            description
              "The total number of octets transmitted out of the
interface.";
          }

          leaf out-unicast-pkts {
            type uint64;
            description
              "The total number of unicast packets that higher-level
protocols requested be transmitted.";
          }

          leaf out-broadcast-pkts {
            type uint64;
            description
              "The total number of broadcast packets that higher-level
protocols requested be transmitted.";
          }

          leaf out-multicast-pkts {
            type uint64;
            description
              "The total number of broadcast packets that higher-level
protocols requested be transmitted.";
          }

          leaf out-discards {
            type uint64;
            description
              "The number of outbound packets that were chosen to be
discarded even though no errors had been detected to
prevent their being transmitted.";
          }

          leaf out-errors {
            type uint64;
            description
              "The number of outbound packets that could not be
transmitted because of errors.";
          }

          leaf rx-pps {
            type uint64;
            description
              "The receive packet per second rate on this interface";
          }

          leaf rx-kbps {
            type uint64;
            description
              "The receive kilobits per second rate on this interface";
          }

          leaf tx-pps {
            type uint64;
            description
              "The transmit packet per second rate on this interface";
          }

          leaf tx-kbps {
            type uint64;
            description
              "The transmit kilobits per second rate on this interface";
          }
        }  // container stats
      }  // list tunnel-if
    }  // container tunnel-oper-data
  }  // module Cisco-IOS-XE-tunnel-oper