module Cisco-IOS-XE-l2tp-oper {

    yang-version 1;

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

    prefix l2tp-ios-xe-oper;

    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 L2TP operational data.
     Copyright (c) 2019 by Cisco Systems, Inc.
     All rights reserved.";

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

    }

    cisco-semver:module-version "1.0.0";

    typedef l2tp-tunnel-state {
      type enumeration {
        enum "l2tp-state-init" {
          value 0;
          description "Init state";
        }
        enum "l2tp-state-idle" {
          value 1;
          description "Idle state";
        }
        enum "l2tp-state-wait-for-sock" {
          value 2;
          description
            "wait for socket state";
        }
        enum "l2tp-state-processing-sccrq" {
          value 3;
          description
            "Processing Start-Control-Connection-Request state";
        }
        enum "l2tp-state-wait-for-sccn" {
          value 4;
          description
            "Wait for Start-Control-Connection-Connected state";
        }
        enum "l2tp-state-processing-scccn" {
          value 5;
          description
            "Processing Start-Control-Connection-Connected state";
        }
        enum "l2tp-state-wait-for-sccrp" {
          value 6;
          description
            "Wait for Start-Control-Connection-Reply state";
        }
        enum "l2tp-state-processing-sccrp" {
          value 7;
          description
            "Processing Start-Control-Connection-Reply state";
        }
        enum "l2tp-state-established" {
          value 8;
          description "Established state";
        }
        enum
          "l2tp-state-established-no-users" {
          value 9;
          description
            "Established with no users state";
        }
        enum "l2tp-state-shutting-down" {
          value 10;
          description "Shutting down state";
        }
        enum "l2tp-state-dead" {
          value 11;
          description "Dead state";
        }
      }
      description "L2TP tunnel state";
    }

    grouping l2tp-tunnel-info {
      description "L2TP tunnel information";
      leaf local-ip-address {
        type inet:ip-address;
        description
          "Tunnel local end point IP address[ipv4/ipv6]";
      }

      leaf remote-ip-address {
        type inet:ip-address;
        description
          "Tunnel remote end point IP address [ipv4/ipv6]";
      }

      leaf local-tunnel-id {
        type uint32;
        description
          "Local tunnel unique identifier";
      }

      leaf remote-tunnel-id {
        type uint32;
        description
          "Remote tunnel unique identifier";
      }

      leaf tunnel-local-name {
        type string;
        description "Local tunnel name";
      }

      leaf tunnel-remote-name {
        type string;
        description "Remote tunnel name";
      }

      leaf l2tp-class-name {
        type string;
        description
          "L2TP class name for the tunnel";
      }

      leaf tunnel-state {
        type l2tp-tunnel-state;
        description "Tunnel state";
      }

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

      leaf local-port {
        type uint16;
        description "Local port number";
      }

      leaf remote-port {
        type uint16;
        description "Remote port number";
      }

      leaf ip-protocol-type {
        type uint16;
        description "IP protocol number";
      }

      leaf is-path-mtu-enabled {
        type uint16;
        description
          "True if path MTU is set";
      }
    }  // grouping l2tp-tunnel-info

    grouping l2tp-tunnel-packet-counter {
      description "Tunnel packet counters";
      leaf packets-in-ipv4 {
        type uint64;
        units "packets";
        description
          "Incoming IPV4 packets count";
      }

      leaf packets-out-ipv4 {
        type uint64;
        units "packets";
        description
          "Outgoing IPV4 packets count";
      }

      leaf bytes-in-ipv4 {
        type uint64;
        units "bytes";
        description "Incoming IPV4 packets";
      }

      leaf bytes-out-ipv4 {
        type uint64;
        units "bytes";
        description "Outgoing IPV4 packets";
      }

      leaf packets-in-ipv6 {
        type uint64;
        units "packets";
        description
          "Incoming IPV6 packets count";
      }

      leaf packets-out-ipv6 {
        type uint64;
        units "packets";
        description
          "Outgoing IPV6 packets count";
      }

      leaf bytes-in-ipv6 {
        type uint64;
        units "bytes";
        description "Incoming IPV6 packets";
      }

      leaf bytes-out-ipv6 {
        type uint64;
        units "bytes";
        description "Outgoing IPV6 packets";
      }
    }  // grouping l2tp-tunnel-packet-counter

    grouping l2tp-tunnel-counter {
      description "Tunnel statistics";
      leaf local-tunnel-id {
        type uint32;
        description
          "Local tunnel unique identifier";
      }

      leaf last-state-change-time {
        type yang:date-and-time;
        description
          "Time since the last state change occurred";
      }

      leaf last-counter-clear-time {
        type yang:date-and-time;
        description
          "Time when last clear happened";
      }

      container count-since-clear {
        description
          "Packet counters by taking last clear into account";
        uses l2tp-ios-xe-oper:l2tp-tunnel-packet-counter;
      }  // container count-since-clear

      container count-ignore-clear {
        description
          "Packet counters ignoring the last clear";
        uses l2tp-ios-xe-oper:l2tp-tunnel-packet-counter;
      }  // container count-ignore-clear

      leaf total-resend {
        type uint32;
        units "packets";
        description
          "Total number of packets were resend";
      }

      leaf zlb-acks-sent {
        type uint32;
        units "packets";
        description
          "Zero-Length Body acks sent";
      }

      leaf out-of-order-drops {
        type uint32;
        units "packets";
        description
          "Total number of out of order packets were dropped";
      }

      leaf out-of-order-reorder {
        type uint32;
        units "packets";
        description
          "Total number of out of order packets were reordered";
      }

      leaf peer-authen-failed {
        type uint32;
        units "packets";
        description
          "Peer authentication failed";
      }

      leaf congestion-ctrl-avoid-pkts {
        type uint16;
        units "packets";
        description
          "Packets count in congestion avoidance mode";
      }
    }  // grouping l2tp-tunnel-counter

    grouping l2tp-tunnel-parameters {
      description "L2TP tunnel parameters";
      leaf local-tunnel-id {
        type uint32;
        description
          "Local tunnel unique identifier";
      }

      leaf tx-sequence-number {
        type uint16;
        description "Send sequence number";
      }

      leaf rx-sequence-number {
        type uint16;
        description
          "Receive sequence number";
      }

      leaf local-window-size {
        type uint16;
        units "packets";
        description "Local window size";
      }

      leaf remote-window-size {
        type uint16;
        units "packets";
        description "Remote window size";
      }

      leaf rxed-remote-window-size {
        type uint16;
        units "packets";
        description
          "Received remote window size";
      }

      leaf retransmission-time {
        type uint16;
        units "seconds";
        description "Retransmission time";
      }

      leaf max-retransmission-time {
        type uint16;
        units "seconds";
        description
          "Maximum retransmission time";
      }

      leaf unsent-queue-size {
        type uint16;
        units "packets";
        description "Un-sent queue size";
      }

      leaf max-unsent-queue-size {
        type uint16;
        units "packets";
        description
          "Maximum un-sent queue size";
      }

      leaf resend-queue-size {
        type uint16;
        units "packets";
        description "Resend queue size";
      }

      leaf max-resend-queue-size {
        type uint16;
        units "packets";
        description
          "Maximum resent queue size";
      }

      leaf-list retrans-distr {
        type uint16;
        units "packets";
        ordered-by user;
        description
          "Retransmit time distribution";
      }

      leaf number-of-digests {
        type uint16;
        description
          "Control message authentication is enabled with
         how many digest secrets";
      }

      leaf congestion-window-size {
        type uint16;
        units "packets";
        description
          "Congestion control window size";
      }

      leaf slow-start-threshold {
        type uint16;
        units "packets";
        description
          "Threshold limit.The point at which the sending device
         switches operation from slow start mode to
         congestion avoidance mode";
      }

      leaf is-local-window-size-default {
        type boolean;
        description
          "True if local window size is default";
      }

      leaf is-max-remote-window-size {
        type boolean;
        description
          "True if maximum remote window size is set";
      }

      leaf is-locally-initiated {
        type boolean;
        description
          "True if the tunnel was locally initiated or
         False if the tunnel was initiated by the remote end";
      }

      leaf is-congestion-ctrl-slow-start {
        type boolean;
        description
          "True if congestion control mode is slow start";
      }

      leaf is-congestion-ctrl-enabled {
        type boolean;
        description
          "True if congestion control is enabled";
      }

      leaf using-digest-secret2 {
        type boolean;
        description
          "True if control message authentication is enabled";
      }

      leaf is-incomplete-export {
        type boolean;
        description
          "True if unable to export the data";
      }

      leaf queue-check-attempts {
        type uint16;
        description
          "Number of times packet queue check is hit,
         before shutting down the tunnel. This delays tunnel shut down,
         if control channel has outstanding packets.";
      }

      leaf max-queue-check-attempts {
        type uint16;
        description
          "Maximum number of attempts allowed to check packet queue";
      }
    }  // grouping l2tp-tunnel-parameters

    container l2tp-oper-data {
      config false;
      description "L2TP operational data";
      list l2tp-tunnel-info {
        key "local-tunnel-id";
        description
          "L2TP tunnel information";
        uses l2tp-ios-xe-oper:l2tp-tunnel-info;
      }  // list l2tp-tunnel-info

      list l2tp-tunnel-counter {
        key "local-tunnel-id";
        description "Tunnel packet counters";
        uses l2tp-ios-xe-oper:l2tp-tunnel-counter;
      }  // list l2tp-tunnel-counter

      list l2tp-tunnel-parameters {
        key "local-tunnel-id";
        description "Tunnel parameters";
        uses l2tp-ios-xe-oper:l2tp-tunnel-parameters;
      }  // list l2tp-tunnel-parameters
    }  // container l2tp-oper-data
  }  // module Cisco-IOS-XE-l2tp-oper