module Cisco-IOS-XR-tunnel-vpdn-oper {

    yang-version 1;

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

    prefix tunnel-vpdn-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-tunnel-vpdn-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-vpdn package operational data.

This module contains definitions
for the following management objects:
  vpdn: VPDN operational data

Copyright (c) 2013-2019 by Cisco Systems, Inc.
All rights reserved.";

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

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

    semver:module-version "1.0.1";

    container vpdn {
      config false;
      description "VPDN 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 sessions {
            description "VPDN session list";
            list session {
              key "session-label";
              description
                " VPDN session information";
              leaf session-label {
                type xr:Hex-integer;
                description "Session label";
              }

              container session {
                description "Session data";
                leaf last-change {
                  type string;
                  description
                    "Elapsed time since last change in hh:mm:ss
format";
                }

                leaf interface-name {
                  type xr:Interface-name;
                  description
                    "Session interface name";
                }

                leaf username {
                  type string;
                  description
                    "Authentication username";
                }

                leaf domain-name {
                  type string;
                  description "Domain name";
                }

                leaf state {
                  type Session-state;
                  description
                    "Session state";
                }

                leaf l2tp-session-id {
                  type uint16;
                  description
                    "L2TP session ID";
                }

                leaf l2tp-tunnel-id {
                  type uint16;
                  description
                    "L2TP tunnel ID";
                }

                leaf srg-slave {
                  type boolean;
                  description
                    "Session SRG Slave";
                }
              }  // container session

              container l2tp {
                description "L2TP data";
                leaf local-endpoint {
                  type inet:ipv4-address;
                  description
                    "Local endpoint IP address";
                }

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

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

                leaf is-l2tp-class-attribute-mask-set {
                  type boolean;
                  description
                    "True if L2TP class attribute mask is set";
                }

                leaf local-tunnel-id {
                  type uint16;
                  description
                    "Local tunnel ID";
                }

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

                leaf local-session-id {
                  type uint16;
                  description
                    "Local session ID";
                }

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

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

                leaf tunnel-client-authentication-id {
                  type string;
                  description
                    "Tunnel client authentication ID";
                }

                leaf tunnel-server-authentication-id {
                  type string;
                  description
                    "Tunnel server authentication ID";
                }

                leaf tunnel-assignment-id {
                  type string;
                  description
                    "Tunnel assignment ID";
                }

                leaf is-tunnel-authentication-enabled {
                  type boolean;
                  description
                    "True if tunnel authentication is enabled";
                }
              }  // container l2tp

              container subscriber {
                description
                  "Subscriber data";
                leaf nas-port-id-val {
                  type string;
                  description
                    "NAS port ID Val";
                }

                leaf nas-port-type {
                  type string;
                  description
                    "NAS port type";
                }

                leaf physical-channel-id {
                  type uint32;
                  description
                    "Physical channel ID";
                }

                leaf receive-connect-speed {
                  type uint64;
                  units "nanosecond";
                  description
                    "Receive connect speed in nanoseconds";
                }

                leaf transmit-connect-speed {
                  type uint64;
                  units "nanosecond";
                  description
                    "Transmit connect speed in nanoseconds";
                }
              }  // container subscriber

              container configuration {
                description
                  "Configuration data";
                container vpn-id {
                  description "VPN ID";
                  leaf oui {
                    type uint32;
                    description "OUI";
                  }

                  leaf index {
                    type uint32;
                    description "Index";
                  }
                }  // container vpn-id

                leaf template-name {
                  type string;
                  description
                    "Template name";
                }

                leaf vrf-name {
                  type string;
                  description "VRF name";
                }

                leaf l2tp-busy-timeout {
                  type uint16;
                  units "second";
                  description
                    "L2TP busy timeout in seconds";
                }

                leaf tos-mode {
                  type Tos-mode;
                  description "TOS mode";
                }

                leaf tos {
                  type uint8;
                  description
                    "TOS setting value";
                }

                leaf dsl-line-forwarding {
                  type boolean;
                  description
                    "True if DSL line info forwarding is enabled";
                }
              }  // container configuration

              leaf setup-time {
                type uint32;
                description
                  "Time to setup session in sec:msec";
              }

              leaf parent-interface-name {
                type xr:Interface-name;
                description
                  "Parent interface name";
              }
            }  // list session
          }  // container sessions

          container tunnel-destinations {
            description
              "VPDN tunnel Destinations";
            list tunnel-destination {
              description
                "VPDN tunnel destination information";
              leaf vrf-name {
                type xr:Cisco-ios-xr-string;
                description "VRF name";
              }

              leaf address {
                type inet:ipv4-address-no-zone;
                description "IP address";
              }

              leaf vrf-name-xr {
                type string;
                description "VRF name";
              }

              leaf load {
                type uint32;
                description
                  "Current load on LNS";
              }

              leaf status {
                type Lsg-status;
                description "Status of LNS";
              }

              leaf connects {
                type uint32;
                description
                  "Total count of tunnels connected";
              }

              leaf disconnects {
                type uint32;
                description
                  "Total count of tunnels disconnected";
              }

              leaf retry {
                type uint32;
                description "Retries";
              }

              leaf status-change-time {
                type uint32;
                units "second";
                description
                  "Seconds since last status change";
              }
            }  // list tunnel-destination
          }  // container tunnel-destinations

          container vpdn-mirroring {
            description
              "VPDN Mirroring Statistics";
            container qad-send-stats {
              description "qad send stats";
              leaf msgs-sent {
                type uint32;
                description "msgs sent";
              }

              leaf acks-sent {
                type uint32;
                description "acks sent";
              }

              leaf no-partner {
                type uint32;
                description "no partner";
              }

              leaf sends-failed {
                type uint32;
                description "sends failed";
              }

              leaf acks-failed {
                type uint32;
                description "acks failed";
              }

              leaf pending-acks {
                type uint32;
                description "pending acks";
              }

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

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

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

              leaf sends-fragment {
                type uint32;
                description "sends fragment";
              }

              leaf qad-last-seq-number {
                type uint32;
                description
                  "qad last seq number";
              }

              leaf qad-frag-count {
                type uint32;
                description "qad frag count";
              }

              leaf qad-ack-count {
                type uint32;
                description "qad ack count";
              }

              leaf qad-unknown-acks {
                type uint32;
                description
                  "qad unknown acks";
              }

              leaf qad-timeouts {
                type uint32;
                description "qad timeouts";
              }

              leaf qad-rx-count {
                type uint32;
                description "qad rx count";
              }

              leaf qad-rx-list-count {
                type uint32;
                description
                  "qad rx list count";
              }

              leaf qad-rx-list-q-size {
                type uint32;
                description
                  "qad rx list q size";
              }

              leaf qad-rx-first-seq-number {
                type uint32;
                description
                  "qad rx first seq number";
              }
            }  // container qad-send-stats

            container qad-recv-stats {
              description "qad recv stats";
              leaf msgs-recvd {
                type uint32;
                description "msgs recvd";
              }

              leaf acks-recvd {
                type uint32;
                description "acks recvd";
              }

              leaf recvd-acks-failed {
                type uint32;
                description
                  "recvd acks failed";
              }

              leaf init-drops {
                type uint32;
                description "init drops";
              }

              leaf msg-drops {
                type uint32;
                description "msg drops";
              }

              leaf ooo-drops {
                type uint32;
                description "ooo drops";
              }

              leaf stale-msgs {
                type uint32;
                description "stale msgs";
              }
            }  // container qad-recv-stats

            container qad-send-stats-last-clear {
              description
                "qad send stats last clear";
              leaf msgs-sent {
                type uint32;
                description "msgs sent";
              }

              leaf acks-sent {
                type uint32;
                description "acks sent";
              }

              leaf no-partner {
                type uint32;
                description "no partner";
              }

              leaf sends-failed {
                type uint32;
                description "sends failed";
              }

              leaf acks-failed {
                type uint32;
                description "acks failed";
              }

              leaf pending-acks {
                type uint32;
                description "pending acks";
              }

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

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

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

              leaf sends-fragment {
                type uint32;
                description "sends fragment";
              }

              leaf qad-last-seq-number {
                type uint32;
                description
                  "qad last seq number";
              }

              leaf qad-frag-count {
                type uint32;
                description "qad frag count";
              }

              leaf qad-ack-count {
                type uint32;
                description "qad ack count";
              }

              leaf qad-unknown-acks {
                type uint32;
                description
                  "qad unknown acks";
              }

              leaf qad-timeouts {
                type uint32;
                description "qad timeouts";
              }

              leaf qad-rx-count {
                type uint32;
                description "qad rx count";
              }

              leaf qad-rx-list-count {
                type uint32;
                description
                  "qad rx list count";
              }

              leaf qad-rx-list-q-size {
                type uint32;
                description
                  "qad rx list q size";
              }

              leaf qad-rx-first-seq-number {
                type uint32;
                description
                  "qad rx first seq number";
              }
            }  // container qad-send-stats-last-clear

            container qad-recv-stats-last-clear {
              description
                "qad recv stats last clear";
              leaf msgs-recvd {
                type uint32;
                description "msgs recvd";
              }

              leaf acks-recvd {
                type uint32;
                description "acks recvd";
              }

              leaf recvd-acks-failed {
                type uint32;
                description
                  "recvd acks failed";
              }

              leaf init-drops {
                type uint32;
                description "init drops";
              }

              leaf msg-drops {
                type uint32;
                description "msg drops";
              }

              leaf ooo-drops {
                type uint32;
                description "ooo drops";
              }

              leaf stale-msgs {
                type uint32;
                description "stale msgs";
              }
            }  // container qad-recv-stats-last-clear

            leaf sync-not-conn-cnt {
              type uint32;
              description
                "sync not conn cnt";
            }

            leaf sso-err-cnt {
              type uint32;
              description "sso err cnt";
            }

            leaf sso-batch-err-cnt {
              type uint32;
              description
                "sso batch err cnt";
            }

            leaf alloc-err-cnt {
              type uint32;
              description "alloc err cnt";
            }

            leaf alloc-cnt {
              type uint32;
              description "alloc cnt";
            }
          }  // container vpdn-mirroring

          container vpdn-redundancy {
            description
              "Show VPDN Redundancy information";
            leaf session-total {
              type uint32;
              description "session total";
            }

            leaf session-synced {
              type uint32;
              description "session synced";
            }

            leaf state {
              type Vpdn-state;
              description "state";
            }

            leaf start-time {
              type uint64;
              description "start time";
            }

            leaf finish-time {
              type uint64;
              description "finish time";
            }

            leaf abort-time {
              type uint64;
              description "abort time";
            }
          }  // container vpdn-redundancy

          container history-failures {
            description
              "VPDN history failure list";
            list history-failure {
              description
                "VPDN history failure information";
              leaf username {
                type string;
                description "Username";
              }

              leaf remote-name {
                type xr:Cisco-ios-xr-string;
                description "Remote name";
              }

              leaf username-xr {
                type string;
                description
                  "Authentication username";
              }

              leaf domain-name {
                type string;
                description "Domain name";
              }

              leaf mid {
                type uint16;
                description
                  "VPDN user session ID";
              }

              leaf nas {
                type string;
                description
                  "Network access server";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description "NAS IP address";
              }

              leaf remote-client-id {
                type uint16;
                description
                  "Remote client ID";
              }

              leaf home-gateway {
                type string;
                description "Home gateway";
              }

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

              leaf local-client-id {
                type uint16;
                description
                  "Local client ID";
              }

              leaf event-time {
                type string;
                description
                  "Event logged time in Ex: Wed Aug  3 10:28:30
2011";
              }

              leaf error-repeat-count {
                type uint16;
                description
                  "Error repeat count";
              }

              leaf failure-type {
                type Vpdn-failcode;
                description "Failure type";
              }
            }  // list history-failure
          }  // container history-failures

          leaf node-name {
            type xr:Node-id;
            description "Node name";
          }
        }  // list node
      }  // container nodes
    }  // container vpdn
  }  // module Cisco-IOS-XR-tunnel-vpdn-oper