Cisco-IOS-XR-tunnel-l2tun-oper

This module contains a collection of YANG definitions for Cisco IOS-XR tunnel-l2tun package operational data. This module conta...

  • Version: 2019-04-05

    Cisco-IOS-XR-tunnel-l2tun-oper@2019-04-05


    
      module Cisco-IOS-XR-tunnel-l2tun-oper {
    
        yang-version 1;
    
        namespace
          "http://cisco.com/ns/yang/Cisco-IOS-XR-tunnel-l2tun-oper";
    
        prefix tunnel-l2tun-oper;
    
        import Cisco-IOS-XR-types {
          prefix xr;
        }
        import cisco-semver {
          prefix semver;
        }
    
        include Cisco-IOS-XR-tunnel-l2tun-oper-sub1 {
          revision-date "2019-04-05";
        }
    
        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 module contains a collection of YANG definitions
         for Cisco IOS-XR tunnel-l2tun package operational data.
         
         This module contains definitions
         for the following management objects:
           l2tp: L2TP operational data
           l2tpv2: L2TPv2 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";
    
        container l2tp {
          config false;
          description "L2TP operational data";
          container nodes {
            description
              "List of nodes for which subscriber data is
             collected";
            list node {
              key "node-name";
              description
                "Subscriber data for a particular node";
              container counters {
                description
                  "L2TP control messages counters";
                container control {
                  description
                    "L2TP control messages counters";
                  container tunnel-xr {
                    description
                      "L2TP control tunnel messages counters";
                    container authentication {
                      description
                        "Tunnel authentication counters";
                      container nonce-avp {
                        description
                          "Nonce AVP statistics";
                        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";
                        }
                      }  // container nonce-avp
    
                      container common-digest {
                        description
                          "Common digest statistics";
                        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";
                        }
                      }  // container common-digest
    
                      container primary-digest {
                        description
                          "Primary digest statistics";
                        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";
                        }
                      }  // container primary-digest
    
                      container secondary-digest {
                        description
                          "Secondary digest statistics";
                        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";
                        }
                      }  // container secondary-digest
    
                      container integrity-check {
                        description
                          "Integrity check statistics";
                        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";
                        }
                      }  // container integrity-check
    
                      container local-secret {
                        description
                          "Local secret statistics";
                        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";
                        }
                      }  // container local-secret
    
                      container challenge-avp {
                        description
                          "Challenge AVP statistics";
                        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";
                        }
                      }  // container challenge-avp
    
                      container challenge-reponse {
                        description
                          "Challenge response statistics";
                        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";
                        }
                      }  // container challenge-reponse
    
                      container overall-statistics {
                        description
                          "Overall statistics";
                        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";
                        }
                      }  // container overall-statistics
                    }  // container authentication
    
                    container global {
                      description
                        "Tunnel counters";
                      container transmit {
                        description
                          "Transmit 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";
                        }
                      }  // container transmit
    
                      container retransmit {
                        description
                          "Re transmit 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";
                        }
                      }  // container retransmit
    
                      container received {
                        description
                          "Received 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";
                        }
                      }  // container received
    
                      container drop {
                        description "Drop 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";
                        }
                      }  // 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";
                      }
                    }  // container global
                  }  // container tunnel-xr
    
                  container tunnels {
                    description
                      "Table of tunnel IDs of control message counters";
                    list tunnel {
                      key "tunnel-id";
                      description
                        "L2TP tunnel control message counters";
                      leaf tunnel-id {
                        type uint32;
                        description
                          "L2TP tunnel ID";
                      }
    
                      container brief {
                        description
                          "L2TP control message local and remote addresses";
                        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";
                        }
                      }  // container brief
    
                      container global {
                        description
                          "Global data";
                        container transmit {
                          description
                            "Transmit 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";
                          }
                        }  // container transmit
    
                        container retransmit {
                          description
                            "Re transmit 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";
                          }
                        }  // container retransmit
    
                        container received {
                          description
                            "Received 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";
                          }
                        }  // container received
    
                        container drop {
                          description
                            "Drop 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";
                          }
                        }  // 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";
                        }
                      }  // container global
                    }  // list tunnel
                  }  // container tunnels
                }  // container control
              }  // container counters
    
              leaf node-name {
                type xr:Node-id;
                description "Node name";
              }
    
              container tunnel-configurations {
                description "List of tunnel IDs";
                list tunnel-configuration {
                  key "local-tunnel-id";
                  description
                    "L2TP tunnel information";
                  leaf local-tunnel-id {
                    type uint32;
                    description
                      "Local tunnel ID";
                  }
    
                  container l2tp-class {
                    description
                      "L2Tp class data";
                    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";
                    }
                  }  // container l2tp-class
    
                  leaf remote-tunnel-id {
                    type uint32;
                    description
                      "Remote tunnel ID";
                  }
                }  // list tunnel-configuration
              }  // container tunnel-configurations
    
              container counter-hist-fail {
                description
                  "Failure events leading to disconnection";
                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
              }  // container counter-hist-fail
    
              container classes {
                description
                  "List of L2TP class names";
                list class {
                  key "class-name";
                  description "L2TP class name";
                  leaf class-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..31";
                    }
                    description
                      "L2TP class name";
                  }
    
                  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";
                  }
                }  // list class
              }  // container classes
    
              container tunnels {
                description "List of tunnel IDs";
                list tunnel {
                  key "local-tunnel-id";
                  description
                    "L2TP tunnel  information";
                  leaf local-tunnel-id {
                    type uint32;
                    description
                      "Local tunnel ID";
                  }
    
                  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
                }  // list tunnel
              }  // container tunnels
    
              container sessions {
                description
                  "List of session IDs";
                list session {
                  key "local-tunnel-id local-session-id";
                  description
                    "L2TP information for a particular session";
                  leaf local-tunnel-id {
                    type uint32;
                    description
                      "Local tunnel ID";
                  }
    
                  leaf local-session-id {
                    type uint32;
                    description
                      "Local session ID";
                  }
    
                  container session-application-data {
                    description
                      "Session application data";
                    container xconnect {
                      when
                        "../l2tp-sh-sess-app-type = '4'" {
                        description
                          "../l2tp_sh_sess_app_type = '4'";
                      }
                      description
                        "Xconnect 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";
                      }
                    }  // container xconnect
    
                    container vpdn {
                      when
                        "../l2tp-sh-sess-app-type = '2'" {
                        description
                          "../l2tp_sh_sess_app_type = '2'";
                      }
                      description "VPDN data";
                      leaf username {
                        type string;
                        description
                          "Session username";
                      }
    
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface name";
                      }
                    }  // container vpdn
    
                    leaf l2tp-sh-sess-app-type {
                      type uint32;
                      description
                        "l2tp sh sess app type";
                    }
                  }  // 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";
                  }
                }  // list session
              }  // container sessions
    
              container session {
                description
                  "L2TP control messages counters";
                container unavailable {
                  description
                    "L2TP session unavailable  information";
                  leaf sessions-on-hold {
                    type uint32;
                    description
                      "Number of session ID in hold database";
                  }
                }  // container unavailable
              }  // container session
    
              container internal {
                description
                  "L2TP v2/v3 internal information";
                container internal-stats {
                  description "internal stats";
                  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";
                  }
                }  // container internal-stats
    
                container internal-stats-last-clear {
                  description
                    "internal stats last clear";
                  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";
                  }
                }  // container internal-stats-last-clear
    
                leaf time-last-clear {
                  type uint32;
                  description "time last clear";
                }
              }  // container internal
            }  // list node
          }  // container nodes
        }  // container l2tp
    
        container l2tpv2 {
          config false;
          description "L2TPv2 operational data";
          container nodes {
            description
              "List of nodes for which subscriber data is
             collected";
            list node {
              key "node-name";
              description
                "Subscriber data for a particular node";
              container counters {
                description
                  "L2TP control messages counters";
                container forwarding {
                  description
                    "L2TP forwarding messages counters";
                  container sessions {
                    description
                      "List of class and session IDs";
                    list session {
                      key "tunnel-id session-id";
                      description
                        "L2TP information for a particular session";
                      leaf tunnel-id {
                        type uint32;
                        description
                          "Local tunnel ID";
                      }
    
                      leaf session-id {
                        type uint32;
                        description
                          "Local session ID";
                      }
    
                      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";
                      }
                    }  // list session
                  }  // container sessions
                }  // container forwarding
    
                container control {
                  description
                    "L2TP control messages counters";
                  container tunnel-xr {
                    description
                      "L2TP control tunnel messages counters";
                    container authentication {
                      description
                        "Tunnel authentication counters";
                      container nonce-avp {
                        description
                          "Nonce AVP statistics";
                        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";
                        }
                      }  // container nonce-avp
    
                      container common-digest {
                        description
                          "Common digest statistics";
                        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";
                        }
                      }  // container common-digest
    
                      container primary-digest {
                        description
                          "Primary digest statistics";
                        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";
                        }
                      }  // container primary-digest
    
                      container secondary-digest {
                        description
                          "Secondary digest statistics";
                        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";
                        }
                      }  // container secondary-digest
    
                      container integrity-check {
                        description
                          "Integrity check statistics";
                        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";
                        }
                      }  // container integrity-check
    
                      container local-secret {
                        description
                          "Local secret statistics";
                        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";
                        }
                      }  // container local-secret
    
                      container challenge-avp {
                        description
                          "Challenge AVP statistics";
                        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";
                        }
                      }  // container challenge-avp
    
                      container challenge-reponse {
                        description
                          "Challenge response statistics";
                        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";
                        }
                      }  // container challenge-reponse
    
                      container overall-statistics {
                        description
                          "Overall statistics";
                        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";
                        }
                      }  // container overall-statistics
                    }  // container authentication
    
                    container global {
                      description
                        "Tunnel counters";
                      container transmit {
                        description
                          "Transmit 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";
                        }
                      }  // container transmit
    
                      container retransmit {
                        description
                          "Re transmit 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";
                        }
                      }  // container retransmit
    
                      container received {
                        description
                          "Received 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";
                        }
                      }  // container received
    
                      container drop {
                        description "Drop 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";
                        }
                      }  // 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";
                      }
                    }  // container global
                  }  // container tunnel-xr
    
                  container tunnels {
                    description
                      "Table of tunnel IDs of control message counters";
                    list tunnel {
                      key "tunnel-id";
                      description
                        "L2TP tunnel control message counters";
                      leaf tunnel-id {
                        type uint32;
                        description
                          "L2TP tunnel ID";
                      }
    
                      container brief {
                        description
                          "L2TP control message local and remote addresses";
                        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";
                        }
                      }  // container brief
    
                      container global {
                        description
                          "Global data";
                        container transmit {
                          description
                            "Transmit 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";
                          }
                        }  // container transmit
    
                        container retransmit {
                          description
                            "Re transmit 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";
                          }
                        }  // container retransmit
    
                        container received {
                          description
                            "Received 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";
                          }
                        }  // container received
    
                        container drop {
                          description
                            "Drop 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";
                          }
                        }  // 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";
                        }
                      }  // container global
                    }  // list tunnel
                  }  // container tunnels
                }  // container control
              }  // container counters
    
              container statistics {
                description
                  "L2TP v2 statistics information";
                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";
                }
              }  // container statistics
    
              container tunnel {
                description "L2TPv2 tunnel ";
                container accounting {
                  description
                    "Tunnel accounting counters";
                  container statistics {
                    description
                      "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";
                    }
                  }  // container statistics
                }  // container accounting
              }  // container tunnel
    
              leaf node-name {
                type xr:Node-id;
                description "Node name";
              }
    
              container tunnel-configurations {
                description "List of tunnel IDs";
                list tunnel-configuration {
                  key "local-tunnel-id";
                  description
                    "L2TP tunnel information";
                  leaf local-tunnel-id {
                    type uint32;
                    description
                      "Local tunnel ID";
                  }
    
                  container l2tp-class {
                    description
                      "L2Tp class data";
                    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";
                    }
                  }  // container l2tp-class
    
                  leaf remote-tunnel-id {
                    type uint32;
                    description
                      "Remote tunnel ID";
                  }
                }  // list tunnel-configuration
              }  // container tunnel-configurations
    
              container counter-hist-fail {
                description
                  "Failure events leading to disconnection";
                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
              }  // container counter-hist-fail
    
              container classes {
                description
                  "List of L2TP class names";
                list class {
                  key "class-name";
                  description "L2TP class name";
                  leaf class-name {
                    type xr:Cisco-ios-xr-string {
                      length "1..31";
                    }
                    description
                      "L2TP class name";
                  }
    
                  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";
                  }
                }  // list class
              }  // container classes
    
              container tunnels {
                description "List of tunnel IDs";
                list tunnel {
                  key "local-tunnel-id";
                  description
                    "L2TP tunnel  information";
                  leaf local-tunnel-id {
                    type uint32;
                    description
                      "Local tunnel ID";
                  }
    
                  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
                }  // list tunnel
              }  // container tunnels
    
              container sessions {
                description
                  "List of session IDs";
                list session {
                  key "local-tunnel-id local-session-id";
                  description
                    "L2TP information for a particular session";
                  leaf local-tunnel-id {
                    type uint32;
                    description
                      "Local tunnel ID";
                  }
    
                  leaf local-session-id {
                    type uint32;
                    description
                      "Local session ID";
                  }
    
                  container session-application-data {
                    description
                      "Session application data";
                    container xconnect {
                      when
                        "../l2tp-sh-sess-app-type = '4'" {
                        description
                          "../l2tp_sh_sess_app_type = '4'";
                      }
                      description
                        "Xconnect 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";
                      }
                    }  // container xconnect
    
                    container vpdn {
                      when
                        "../l2tp-sh-sess-app-type = '2'" {
                        description
                          "../l2tp_sh_sess_app_type = '2'";
                      }
                      description "VPDN data";
                      leaf username {
                        type string;
                        description
                          "Session username";
                      }
    
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Interface name";
                      }
                    }  // container vpdn
    
                    leaf l2tp-sh-sess-app-type {
                      type uint32;
                      description
                        "l2tp sh sess app type";
                    }
                  }  // 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";
                  }
                }  // list session
              }  // container sessions
    
              container session {
                description
                  "L2TP control messages counters";
                container unavailable {
                  description
                    "L2TP session unavailable  information";
                  leaf sessions-on-hold {
                    type uint32;
                    description
                      "Number of session ID in hold database";
                  }
                }  // container unavailable
              }  // container session
    
              container internal {
                description
                  "L2TP v2/v3 internal information";
                container internal-stats {
                  description "internal stats";
                  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";
                  }
                }  // container internal-stats
    
                container internal-stats-last-clear {
                  description
                    "internal stats last clear";
                  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";
                  }
                }  // container internal-stats-last-clear
    
                leaf time-last-clear {
                  type uint32;
                  description "time last clear";
                }
              }  // container internal
            }  // list node
          }  // container nodes
        }  // container l2tpv2
      }  // module Cisco-IOS-XR-tunnel-l2tun-oper
    

© 2023 YumaWorks, Inc. All rights reserved.