submodule Cisco-IOS-XR-tunnel-l2tun-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-tunnel-l2tun-oper {
        prefix
          Cisco-IOS-XR-tunnel-l2tun-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    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 tunnel-l2tun package operational data.
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

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

    revision "2018-11-01" {
      description
        "Added Yang support show l2tpv2 internal.";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

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

    semver:module-version "1.0.1";

    typedef Digest-hash {
      type enumeration {
        enum "md5" {
          value 0;
          description "MD5";
        }
        enum "sha1" {
          value 1;
          description "SHA1";
        }
      }
      description "Digest hash types";
    }

    grouping L2TPV2-CC-ACCT-STATS-DATA {
      description
        "L2TPv2 tunnel accounting statistics";
      leaf records-sent-successfully {
        type uint64;
        description
          "Accounting records sent successfully";
      }

      leaf start {
        type uint64;
        description "Accounting start";
      }

      leaf stop {
        type uint64;
        description "Accounting stop";
      }

      leaf reject {
        type uint64;
        description "Accounting reject";
      }

      leaf transport-failures {
        type uint64;
        description "Transport failures";
      }

      leaf positive-acknowledgement {
        type uint64;
        description
          "Positive acknowledgement";
      }

      leaf negative-acknowledgement {
        type uint64;
        description
          "Negative acknowledgement";
      }

      leaf records-checkpointed {
        type uint64;
        description
          "Total records checkpointed";
      }

      leaf records-failed-to-checkpoint {
        type uint64;
        description
          "Records fail to checkpoint";
      }

      leaf records-sent-from-queue {
        type uint64;
        description
          "Records sent from queue";
      }

      leaf memory-failures {
        type uint32;
        description "Memory failures";
      }

      leaf current-size {
        type uint32;
        description
          "Current checkpoint size";
      }

      leaf records-recovered-from-checkpoint {
        type uint32;
        description
          "Records recovered from checkpoint";
      }

      leaf records-fail-to-recover {
        type uint32;
        description
          "Records fail to recover";
      }

      leaf queue-statistics-size {
        type int32;
        description "Queue statistics size";
      }
    }  // grouping L2TPV2-CC-ACCT-STATS-DATA

    grouping L2TPV2-STATS-DATA {
      description "L2TPv2 statistics";
      leaf tunnels {
        type uint32;
        description "Number of tunnels";
      }

      leaf sessions {
        type uint32;
        description "Number of sessions";
      }

      leaf sent-packets {
        type uint32;
        description "Number of packets sent";
      }

      leaf received-packets {
        type uint32;
        description
          "Number of packets received";
      }

      leaf average-packet-processing-time {
        type uint32;
        units "microsecond";
        description
          "Average processing time for received packets
         (in micro seconds)";
      }

      leaf received-out-of-order-packets {
        type uint32;
        description
          "Out of order packets received";
      }

      leaf reorder-packets {
        type uint32;
        description "Re order packets";
      }

      leaf reorder-deviation-packets {
        type uint32;
        description "Re order deviation";
      }

      leaf incoming-dropped-packets {
        type uint32;
        description
          "In coming packets dropped";
      }

      leaf buffered-packets {
        type uint32;
        description "Bufferred packets";
      }

      leaf netio-packets {
        type uint32;
        description "Packets RX in netio";
      }
    }  // grouping L2TPV2-STATS-DATA

    grouping L2TP-SESS-FWD-STATS {
      description "L2TP session PD counters";
      leaf remote-session-id {
        type uint32;
        description "Remote session ID";
      }

      leaf in-packets {
        type uint64;
        description
          "Number of packets sent in";
      }

      leaf out-packets {
        type uint64;
        description
          "Number of packets sent out";
      }

      leaf in-bytes {
        type uint64;
        units "byte";
        description
          "Number of bytes sent in";
      }

      leaf out-bytes {
        type uint64;
        units "byte";
        description
          "Number of bytes sent out";
      }
    }  // grouping L2TP-SESS-FWD-STATS

    grouping L2TP-INTERNAL-BAG-DATA {
      description "L2TP INTERNAL BAG DATA";
      leaf l2tp-sh-l2x-num-tunnels {
        type uint32;
        description
          "l2tp sh l2x num tunnels";
      }

      leaf l2tp-sh-l2x-num-sessions {
        type uint32;
        description
          "l2tp sh l2x num sessions";
      }

      leaf l2tp-sh-l2x-rx-high-water-mark {
        type uint32;
        description
          "l2tp sh l2x rx high water mark";
      }

      leaf l2tp-sh-l2x-ave-msg-process-usecs {
        type uint64;
        description
          "l2tp sh l2x ave msg process usecs";
      }

      leaf l2tp-sh-l2x-num-rx-msgs {
        type uint32;
        description
          "l2tp sh l2x num rx msgs";
      }

      leaf l2tp-sh-l2x-num-tx-msgs {
        type uint32;
        description
          "l2tp sh l2x num tx msgs";
      }

      leaf l2tp-sh-l2x-num-tx-err-drops {
        type uint32;
        description
          "l2tp sh l2x num tx err drops";
      }

      leaf l2tp-sh-l2x-num-tx-conn-drops {
        type uint32;
        description
          "l2tp sh l2x num tx conn drops";
      }

      leaf l2tp-sh-l2x-num-reordered-msgs {
        type uint32;
        description
          "l2tp sh l2x num reordered msgs";
      }

      leaf l2tp-sh-l2x-max-reorder-deviation {
        type uint32;
        description
          "l2tp sh l2x max reorder deviation";
      }

      leaf l2tp-sh-l2x-num-ooo-msgs {
        type uint32;
        description
          "l2tp sh l2x num ooo msgs";
      }

      leaf l2tp-sh-l2x-num-rx-path-drops {
        type uint32;
        description
          "l2tp sh l2x num rx path drops";
      }

      leaf l2tp-sh-l2x-num-rx-path-data-pkt-drops {
        type uint32;
        description
          "l2tp sh l2x num rx path data pkt drops";
      }

      leaf l2tp-sh-l2x-num-rx-queue-drops {
        type uint32;
        description
          "l2tp sh l2x num rx queue drops";
      }

      leaf l2tp-sh-l2x-num-rx-ooo-drops {
        type uint32;
        description
          "l2tp sh l2x num rx ooo drops";
      }

      leaf l2tp-sh-l2x-num-buffered-msgs {
        type uint32;
        description
          "l2tp sh l2x num buffered msgs";
      }

      leaf l2tp-sh-l2x-num-mutex-block {
        type uint32;
        description
          "l2tp sh l2x num mutex block";
      }

      leaf l2tp-sh-l2x-num-bad-len-drops {
        type uint32;
        description
          "l2tp sh l2x num bad len drops";
      }

      leaf l2tp-sh-l2x-num-bad-avp-drops {
        type uint32;
        description
          "l2tp sh l2x num bad avp drops";
      }

      leaf l2tp-sh-l2x-num-missing-cc-id-drops {
        type uint32;
        description
          "l2tp sh l2x num missing cc id drops";
      }

      leaf l2tp-sh-l2x-num-missing-sess-id-drops {
        type uint32;
        description
          "l2tp sh l2x num missing sess id drops";
      }

      leaf l2tp-sh-l2x-num-mismatch-cc-id-drops {
        type uint32;
        description
          "l2tp sh l2x num mismatch cc id drops";
      }

      leaf l2tp-sh-l2x-num-unknown-cc-drops {
        type uint32;
        description
          "l2tp sh l2x num unknown cc drops";
      }

      leaf l2tp-sh-l2x-num-unknown-sess-drops {
        type uint32;
        description
          "l2tp sh l2x num unknown sess drops";
      }

      leaf l2tp-sh-l2x-num-linear-id-search {
        type uint32;
        description
          "l2tp sh l2x num linear id search";
      }

      leaf l2tp-sh-l2x-num-linear-id-search-fail {
        type uint32;
        description
          "l2tp sh l2x num linear id search fail";
      }

      leaf l2tp-sh-l2x-num-netio-pkt-rx {
        type uint32;
        description
          "l2tp sh l2x num netio pkt rx";
      }

      leaf l2tp-sh-l2tun-ave-msg-process-usecs {
        type uint64;
        description
          "l2tp sh l2tun ave msg process usecs";
      }

      leaf l2tp-sh-l2tun-num-rx-msgs {
        type uint32;
        description
          "l2tp sh l2tun num rx msgs";
      }

      leaf l2tp-sh-l2tun-num-tx-msgs {
        type uint32;
        description
          "l2tp sh l2tun num tx msgs";
      }

      leaf l2tp-l2tun-socket-ens-send-error-cnt {
        type uint32;
        description
          "l2tp l2tun socket ens send error cnt";
      }

      leaf l2tp-l2tun-socket-session-accept {
        type uint64;
        description
          "l2tp l2tun socket session accept";
      }

      leaf l2tp-l2tun-socket-session-destroy {
        type uint64;
        description
          "l2tp l2tun socket session destroy";
      }

      leaf l2tp-l2tun-socket-session-connect {
        type uint64;
        description
          "l2tp l2tun socket session connect";
      }

      leaf l2tp-l2tun-socket-session-connect-continue {
        type uint64;
        description
          "l2tp l2tun socket session connect continue";
      }

      leaf l2tp-l2tun-session-connecting {
        type uint64;
        description
          "l2tp l2tun session connecting";
      }

      leaf l2tp-l2tun-session-connected {
        type uint64;
        description
          "l2tp l2tun session connected";
      }

      leaf l2tp-l2tun-session-disconnected {
        type uint64;
        description
          "l2tp l2tun session disconnected";
      }

      leaf l2tp-l2tun-session-incoming {
        type uint64;
        description
          "l2tp l2tun session incoming";
      }

      leaf l2tp-l2tun-session-updated {
        type uint64;
        description
          "l2tp l2tun session updated";
      }

      leaf l2tp-l2tun-session-circuit-status {
        type uint64;
        description
          "l2tp l2tun session circuit status";
      }

      leaf l2x-lpts-pa-stats-setup-cnt {
        type uint32;
        description
          "l2x lpts pa stats setup cnt";
      }

      leaf l2x-lpts-pa-stats-destroy-cnt {
        type uint32;
        description
          "l2x lpts pa stats destroy cnt";
      }

      leaf l2x-lpts-pa-stats-alloc-cnt {
        type uint32;
        description
          "l2x lpts pa stats alloc cnt";
      }

      leaf l2x-lpts-pa-stats-alloc-fail-cnt {
        type uint32;
        description
          "l2x lpts pa stats alloc fail cnt";
      }

      leaf l2x-lpts-pa-stats-init-cnt {
        type uint32;
        description
          "l2x lpts pa stats init cnt";
      }

      leaf l2x-lpts-pa-stats-init-fail-cnt {
        type uint32;
        description
          "l2x lpts pa stats init fail cnt";
      }

      leaf l2x-lpts-pa-stats-free-cnt {
        type uint32;
        description
          "l2x lpts pa stats free cnt";
      }

      leaf l2x-lpts-pa-stats-pulse-cnt {
        type uint32;
        description
          "l2x lpts pa stats pulse cnt";
      }

      leaf l2x-lpts-pa-stats-pulse-fail-cnt {
        type uint32;
        description
          "l2x lpts pa stats pulse fail cnt";
      }

      leaf l2x-lpts-pa-stats-bind-cnt {
        type uint32;
        description
          "l2x lpts pa stats bind cnt";
      }

      leaf l2x-lpts-pa-stats-bind-fail-cnt {
        type uint32;
        description
          "l2x lpts pa stats bind fail cnt";
      }

      leaf l2x-lpts-pa-stats-bind-batch-cnt {
        type uint32;
        description
          "l2x lpts pa stats bind batch cnt";
      }

      leaf l2x-lpts-pa-stats-bind-batch-fail-cnt {
        type uint32;
        description
          "l2x lpts pa stats bind batch fail cnt";
      }

      leaf l2x-lpts-pa-stats-bind-time {
        type uint32;
        description
          "l2x lpts pa stats bind time";
      }

      leaf l2x-lpts-pa-stats-expire-cnt {
        type uint32;
        description
          "l2x lpts pa stats expire cnt";
      }

      leaf l2x-lpts-pa-stats-replay-cnt {
        type uint32;
        description
          "l2x lpts pa stats replay cnt";
      }

      leaf l2x-lpts-pa-stats-replay-batch-cnt {
        type uint32;
        description
          "l2x lpts pa stats replay batch cnt";
      }

      leaf l2x-lpts-pa-stats-replay-time {
        type uint32;
        description
          "l2x lpts pa stats replay time";
      }
    }  // grouping L2TP-INTERNAL-BAG-DATA

    grouping L2TP-INTERNAL-STATS-BAG-DATA {
      description
        "L2TP INTERNAL STATS BAG DATA";
      container internal-stats {
        description "internal stats";
        uses L2TP-INTERNAL-BAG-DATA;
      }  // container internal-stats

      container internal-stats-last-clear {
        description
          "internal stats last clear";
        uses L2TP-INTERNAL-BAG-DATA;
      }  // container internal-stats-last-clear

      leaf time-last-clear {
        type uint32;
        description "time last clear";
      }
    }  // grouping L2TP-INTERNAL-STATS-BAG-DATA

    grouping L2TP-SESSION-ID-HOLD-DB-DATA {
      description "L2TP hold database";
      leaf sessions-on-hold {
        type uint32;
        description
          "Number of session ID in hold database";
      }
    }  // grouping L2TP-SESSION-ID-HOLD-DB-DATA

    grouping L2TP-CTL-MSG-BRIEF-DATA {
      description
        "L2TP control message brief data";
      leaf remote-tunnel-id {
        type uint32;
        description "Remote tunnel ID";
      }

      leaf local-address {
        type inet:ipv4-address;
        description "Local IP address";
      }

      leaf remote-address {
        type inet:ipv4-address;
        description "Remote IP address";
      }
    }  // grouping L2TP-CTL-MSG-BRIEF-DATA

    grouping L2TP-CTRL-MSG-STATS-DATA {
      description
        "L2TP control message statistics data";
      container brief {
        description
          "L2TP control message local and remote addresses";
        uses L2TP-CTL-MSG-BRIEF-DATA;
      }  // container brief

      container global {
        description "Global data";
        uses L2TP-CTRL-MSG-STATS-GLOBAL-DATA;
      }  // container global
    }  // grouping L2TP-CTRL-MSG-STATS-DATA

    grouping L2TP-CTRL-MSG-COUNTS {
      description
        "L2TP control message counters data";
      leaf unknown-packets {
        type uint32;
        description "Unknown packets";
      }

      leaf zero-length-body-packets {
        type uint32;
        description
          "Zero length body packets";
      }

      leaf start-control-connection-requests {
        type uint32;
        description
          "Start control connection requests";
      }

      leaf start-control-connection-replies {
        type uint32;
        description
          "Start control connection replies";
      }

      leaf start-control-connection-notifications {
        type uint32;
        description
          "Start control connection notifications";
      }

      leaf stop-control-connection-notifications {
        type uint32;
        description
          "Stop control connection notifications";
      }

      leaf hello-packets {
        type uint32;
        description "Keep alive messages";
      }

      leaf outgoing-call-requests {
        type uint32;
        description "Outgoing call requests";
      }

      leaf outgoing-call-replies {
        type uint32;
        description "Outgoing call replies";
      }

      leaf outgoing-call-connected-packets {
        type uint32;
        description
          "Outgoing call connected packets";
      }

      leaf incoming-call-requests {
        type uint32;
        description "Incoming call requests";
      }

      leaf incoming-call-replies {
        type uint32;
        description "Incoming call replies";
      }

      leaf incoming-call-connected-packets {
        type uint32;
        description
          "Incoming call connected packets";
      }

      leaf call-disconnect-notify-packets {
        type uint32;
        description
          "Call disconnect notify packets";
      }

      leaf wan-error-notify-packets {
        type uint32;
        description
          "WAN error notify packets";
      }

      leaf set-link-info-packets {
        type uint32;
        description "Set link info packets";
      }

      leaf service-relay-requests {
        type uint32;
        description
          "Service relay request counts";
      }

      leaf service-relay-replies {
        type uint32;
        description
          "Service relay reply counts";
      }

      leaf acknowledgement-packets {
        type uint32;
        description
          "Packets acknowledgement";
      }
    }  // grouping L2TP-CTRL-MSG-COUNTS

    grouping L2TP-CTRL-MSG-STATS-GLOBAL-DATA {
      description
        "L2TP control message global data";
      container transmit {
        description "Transmit data";
        uses L2TP-CTRL-MSG-COUNTS;
      }  // container transmit

      container retransmit {
        description "Re transmit data";
        uses L2TP-CTRL-MSG-COUNTS;
      }  // container retransmit

      container received {
        description "Received data";
        uses L2TP-CTRL-MSG-COUNTS;
      }  // container received

      container drop {
        description "Drop data";
        uses L2TP-CTRL-MSG-COUNTS;
      }  // container drop

      leaf total-transmit {
        type uint32;
        description "Total transmit";
      }

      leaf total-retransmit {
        type uint32;
        description "Total retransmit";
      }

      leaf total-received {
        type uint32;
        description "Total received";
      }

      leaf total-drop {
        type uint32;
        description "Total drop";
      }
    }  // grouping L2TP-CTRL-MSG-STATS-GLOBAL-DATA

    grouping L2TP-COMMON-DATA {
      description "L2TP common data";
      leaf validate {
        type uint32;
        description "Validate";
      }

      leaf bad-hash {
        type uint32;
        description "Bad hash";
      }

      leaf bad-length {
        type uint32;
        description "Bad length";
      }

      leaf ignored {
        type uint32;
        description "Ignored";
      }

      leaf missing {
        type uint32;
        description "Missing";
      }

      leaf passed {
        type uint32;
        description "Passed";
      }

      leaf failed {
        type uint32;
        description "Failed";
      }

      leaf skipped {
        type uint32;
        description "Skipped";
      }

      leaf generate-response-failures {
        type uint32;
        description "Generate response fail";
      }

      leaf unexpected {
        type uint32;
        description "Unexpected";
      }

      leaf unexpected-zlb {
        type uint32;
        description "Unexpected ZLB";
      }
    }  // grouping L2TP-COMMON-DATA

    grouping L2TP-AUTHEN-STATS-DATA {
      description
        "L2TP authentication statistics";
      container nonce-avp {
        description "Nonce AVP statistics";
        uses L2TP-COMMON-DATA;
      }  // container nonce-avp

      container common-digest {
        description
          "Common digest statistics";
        uses L2TP-COMMON-DATA;
      }  // container common-digest

      container primary-digest {
        description
          "Primary digest statistics";
        uses L2TP-COMMON-DATA;
      }  // container primary-digest

      container secondary-digest {
        description
          "Secondary digest statistics";
        uses L2TP-COMMON-DATA;
      }  // container secondary-digest

      container integrity-check {
        description
          "Integrity check statistics";
        uses L2TP-COMMON-DATA;
      }  // container integrity-check

      container local-secret {
        description
          "Local secret statistics";
        uses L2TP-COMMON-DATA;
      }  // container local-secret

      container challenge-avp {
        description
          "Challenge AVP statistics";
        uses L2TP-COMMON-DATA;
      }  // container challenge-avp

      container challenge-reponse {
        description
          "Challenge response statistics";
        uses L2TP-COMMON-DATA;
      }  // container challenge-reponse

      container overall-statistics {
        description "Overall statistics";
        uses L2TP-COMMON-DATA;
      }  // container overall-statistics
    }  // grouping L2TP-AUTHEN-STATS-DATA

    grouping L2TP-SESSION-VPDN {
      description
        "VPDN specific session data";
      leaf username {
        type string;
        description "Session username";
      }

      leaf interface-name {
        type xr:Interface-name;
        description "Interface name";
      }
    }  // grouping L2TP-SESSION-VPDN

    grouping L2TP-SESSION-XCONNECT {
      description
        "Xconnect specific session data";
      leaf circuit-name {
        type string;
        description "Circuit name";
      }

      leaf sessionvc-id {
        type uint32;
        description "Session VC ID";
      }

      leaf is-circuit-state-up {
        type boolean;
        description
          "True if circuit state is up";
      }

      leaf is-local-circuit-state-up {
        type boolean;
        description
          "True if local circuit state is up";
      }

      leaf is-remote-circuit-state-up {
        type boolean;
        description
          "True if remote circuit state is up";
      }

      leaf ipv6-protocol-tunneling {
        type boolean;
        description "IPv6ProtocolTunneling";
      }
    }  // grouping L2TP-SESSION-XCONNECT

    grouping SESSION-APP {
      description "Session application data";
      container xconnect {
        when
          "../l2tp-sh-sess-app-type = '4'" {
          description
            "../l2tp_sh_sess_app_type = '4'";
        }
        description "Xconnect data";
        uses L2TP-SESSION-XCONNECT;
      }  // container xconnect

      container vpdn {
        when
          "../l2tp-sh-sess-app-type = '2'" {
          description
            "../l2tp_sh_sess_app_type = '2'";
        }
        description "VPDN data";
        uses L2TP-SESSION-VPDN;
      }  // container vpdn

      leaf l2tp-sh-sess-app-type {
        type uint32;
        description "l2tp sh sess app type";
      }
    }  // grouping SESSION-APP

    grouping L2TP-SESSION-INFO {
      description "L2TP session information";
      container session-application-data {
        description
          "Session application data";
        uses SESSION-APP;
      }  // container session-application-data

      leaf local-ip-address {
        type inet:ipv4-address;
        description
          "Local session IP address";
      }

      leaf remote-ip-address {
        type inet:ipv4-address;
        description
          "Remote session IP address";
      }

      leaf l2tp-sh-sess-udp-lport {
        type uint16;
        description "l2tp sh sess udp lport";
      }

      leaf l2tp-sh-sess-udp-rport {
        type uint16;
        description "l2tp sh sess udp rport";
      }

      leaf protocol {
        type uint8;
        description "Protocol";
      }

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

      leaf call-serial-number {
        type uint32;
        description "Call serial number";
      }

      leaf local-tunnel-name {
        type string {
          length "0..256";
        }
        description "Local tunnel name";
      }

      leaf remote-tunnel-name {
        type string {
          length "0..256";
        }
        description "Remote tunnel name";
      }

      leaf remote-session-id {
        type uint32;
        description "Remote session ID";
      }

      leaf l2tp-sh-sess-tie-breaker-enabled {
        type uint8;
        description
          "l2tp sh sess tie breaker enabled";
      }

      leaf l2tp-sh-sess-tie-breaker {
        type uint64;
        description
          "l2tp sh sess tie breaker";
      }

      leaf is-session-manual {
        type boolean;
        description
          "True if session is manual";
      }

      leaf is-session-up {
        type boolean;
        description "True if session is up";
      }

      leaf is-udp-checksum-enabled {
        type boolean;
        description
          "True if UDP checksum enabled";
      }

      leaf is-sequencing-on {
        type boolean;
        description
          "True if session sequence is on";
      }

      leaf is-session-state-established {
        type boolean;
        description
          "True if session state is established";
      }

      leaf is-session-locally-initiated {
        type boolean;
        description
          "True if session initiated locally";
      }

      leaf is-conditional-debug-enabled {
        type boolean;
        description
          "True if conditional debugging is enabled";
      }

      leaf unique-id {
        type uint32;
        description "Unique ID";
      }

      leaf interface-name {
        type string {
          length "0..256";
        }
        description "Interface name";
      }
    }  // grouping L2TP-SESSION-INFO

    grouping L2TP-CC-INFO {
      description "L2TP tunnel information";
      leaf local-address {
        type inet:ipv4-address;
        description "Local tunnel address";
      }

      leaf remote-address {
        type inet:ipv4-address;
        description "Remote tunnel address";
      }

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

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

      leaf protocol {
        type uint8;
        description "Protocol";
      }

      leaf is-pmtu-enabled {
        type boolean;
        description
          "True if tunnel PMTU checking is enabled";
      }

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

      leaf local-tunnel-name {
        type string {
          length "0..256";
        }
        description "Local tunnel name";
      }

      leaf remote-tunnel-name {
        type string {
          length "0..256";
        }
        description "Remote tunnel name";
      }

      leaf class-name {
        type string {
          length "0..256";
        }
        description "L2TP class name";
      }

      leaf active-sessions {
        type uint32;
        description
          "Number of active sessions";
      }

      leaf sequence-ns {
        type uint16;
        description "Sequence NS";
      }

      leaf sequence-nr {
        type uint16;
        description "Sequence NR";
      }

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

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

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

      leaf maximum-retransmission-time {
        type uint16;
        units "second";
        description
          "Maximum retransmission time in seconds";
      }

      leaf unsent-queue-size {
        type uint16;
        description "Unsent queue size";
      }

      leaf unsent-maximum-queue-size {
        type uint16;
        description
          "Unsent maximum queue size";
      }

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

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

      leaf order-queue-size {
        type uint16;
        description "Order queue size";
      }

      leaf packet-queue-check {
        type uint16;
        description
          "Current number session packet queue check";
      }

      leaf digest-secrets {
        type uint16;
        description
          "Control message authentication with digest
         secrets";
      }

      leaf resends {
        type uint32;
        description "Total resends";
      }

      leaf zero-length-body-acknowledgement-sent {
        type uint32;
        description
          "Total zero length body acknowledgement";
      }

      leaf total-out-of-order-drop-packets {
        type uint32;
        description
          "Total out of order dropped packets";
      }

      leaf total-out-of-order-reorder-packets {
        type uint32;
        description
          "Total out of order reorder packets";
      }

      leaf total-peer-authentication-failures {
        type uint32;
        description
          "Number of peer authentication failures";
      }

      leaf is-tunnel-up {
        type boolean;
        description "True if tunnel is up";
      }

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

      list retransmit-time {
        max-elements 9;
        description
          "Retransmit time distribution in seconds";
        leaf entry {
          type uint16;
          units "second";
          description
            "Retransmit time distribution in seconds";
        }
      }  // list retransmit-time
    }  // grouping L2TP-CC-INFO

    grouping L2TP-HIST-FAIL-STATS-BAG-DATA {
      description
        "L2TP history failure stats in either TX or RX
       direction";
      leaf sess-down-tmout {
        type uint32;
        description
          "sesions affected due to timeout";
      }

      leaf tx-counters {
        type yang:hex-string;
        description "Send side counters";
      }

      leaf rx-counters {
        type yang:hex-string;
        description "Receive side counters";
      }

      list pkt-timeout {
        max-elements 24;
        description
          "timeout events by packet";
        leaf entry {
          type uint32;
          description
            "timeout events by packet";
        }
      }  // list pkt-timeout
    }  // grouping L2TP-HIST-FAIL-STATS-BAG-DATA

    grouping L2TP-CC-CLASS-DATA {
      description "L2TP class";
      leaf ip-tos {
        type uint8;
        description "IP TOS";
      }

      leaf vrf-name {
        type string {
          length "0..256";
        }
        description "VRF name";
      }

      leaf receive-window-size {
        type uint16;
        description "Receive window size";
      }

      leaf class-name-xr {
        type string {
          length "0..256";
        }
        description "Class name";
      }

      leaf digest-hash {
        type Digest-hash;
        description
          "Hash configured as MD5 or SHA1";
      }

      leaf password {
        type string {
          length "0..25";
        }
        description "Password";
      }

      leaf encoded-password {
        type string {
          length "0..256";
        }
        description "Encoded password";
      }

      leaf host-name {
        type string {
          length "0..256";
        }
        description "Host name";
      }

      leaf accounting-method-list {
        type string {
          length "0..256";
        }
        description "Accounting List";
      }

      leaf hello-timeout {
        type uint32;
        units "second";
        description
          "Hello timeout value in seconds";
      }

      leaf setup-timeout {
        type uint32;
        units "second";
        description
          "Timeout setup value in seconds";
      }

      leaf retransmit-minimum-timeout {
        type uint32;
        units "second";
        description
          "Retransmit minimum timeout in seconds";
      }

      leaf retransmit-maximum-timeout {
        type uint32;
        units "second";
        description
          "Retransmit maximum timeout in seconds";
      }

      leaf initial-retransmit-minimum-timeout {
        type uint32;
        units "second";
        description
          "Initial timeout minimum in seconds";
      }

      leaf initial-retransmit-maximum-timeout {
        type uint32;
        units "second";
        description
          "Initial timeout maximum in seconds";
      }

      leaf timeout-no-user {
        type uint32;
        description "Timeout no user";
      }

      leaf retransmit-retries {
        type uint32;
        description "Retransmit retries";
      }

      leaf initial-retransmit-retries {
        type uint32;
        description
          "Initial retransmit retries";
      }

      leaf is-authentication-enabled {
        type boolean;
        description
          "True if authentication is enabled";
      }

      leaf is-hidden {
        type boolean;
        description
          "True if class is hidden";
      }

      leaf is-digest-enabled {
        type boolean;
        description
          "True if digest authentication is enabled";
      }

      leaf is-digest-check-enabled {
        type boolean;
        description
          "True if digest check is enabled";
      }

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

      leaf is-peer-address-checked {
        type boolean;
        description
          "True if peer address is checked";
      }
    }  // grouping L2TP-CC-CLASS-DATA

    grouping L2TP-CC-CFG-DATA {
      description
        "L2TP tunnel configuration";
      container l2tp-class {
        description "L2Tp class data";
        uses L2TP-CC-CLASS-DATA;
      }  // container l2tp-class

      leaf remote-tunnel-id {
        type uint32;
        description "Remote tunnel ID";
      }
    }  // grouping L2TP-CC-CFG-DATA
  }  // submodule Cisco-IOS-XR-tunnel-l2tun-oper-sub1