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

    yang-version 1;

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

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

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR tunnel-vpdn package 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";

    typedef Vpdn-failcode {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "peer-action" {
          value 1;
          description "Peer action";
        }
        enum "authentication" {
          value 2;
          description "Authentication";
        }
        enum "authentication-error" {
          value 3;
          description "Authentication";
        }
        enum "authentication-failed" {
          value 4;
          description "Authentication";
        }
        enum "authorization" {
          value 5;
          description "Authorization";
        }
        enum "authorization-failed" {
          value 6;
          description "Authorization";
        }
        enum "home-gatewayfailure" {
          value 7;
          description
            "No resources available";
        }
        enum "connection-termination" {
          value 8;
          description
            "Connection termination";
        }
        enum "no-resources-available" {
          value 9;
          description
            "No resources available";
        }
        enum "timer-expiry" {
          value 10;
          description "Timer expiry";
        }
        enum "session-mid-exceeded" {
          value 11;
          description "Session limit";
        }
        enum "soft-shut" {
          value 12;
          description "Softshut";
        }
        enum "session-limit-exceeded" {
          value 13;
          description "Session limit";
        }
        enum "administrative" {
          value 14;
          description "Administrative";
        }
        enum "link-failure" {
          value 15;
          description "Link failure";
        }
        enum "security" {
          value 16;
          description "Security";
        }
        enum "tunnel-in-resync" {
          value 17;
          description "Tunnel in HA resync";
        }
        enum "call-prarmeters" {
          value 18;
          description "Call parameters";
        }
      }
      description "VPDN failure types";
    }

    typedef Vpdn-state {
      type enumeration {
        enum "initial-state" {
          value 0;
          description "Initial state";
        }
        enum "init-sync-in-progress" {
          value 1;
          description
            "Initial Sync in progress";
        }
        enum "steady-state" {
          value 2;
          description "Initial Sync Done";
        }
      }
      description "Vpdn states";
    }

    typedef Lsg-status {
      type enumeration {
        enum "none" {
          value 0;
          description
            "Member not initialized.";
        }
        enum "active" {
          value 1;
          description "Member is active.";
        }
        enum "down" {
          value 2;
          description
            "Member is down, cannot create new sessions.";
        }
        enum "testable" {
          value 3;
          description
            "Member is ready for new sessions.";
        }
        enum "testing" {
          value 4;
          description
            "Member is being tested for new session";
        }
      }
      description "LSG Status";
    }

    typedef Tos-mode {
      type enumeration {
        enum "default" {
          value 0;
          description "default";
        }
        enum "set" {
          value 1;
          description "set";
        }
        enum "reflect" {
          value 2;
          description "reflect";
        }
      }
      description "TOS modes";
    }

    typedef Session-state {
      type enumeration {
        enum "idle" {
          value 0;
          description "Idle state";
        }
        enum "connected" {
          value 1;
          description "Connected state";
        }
        enum "established" {
          value 2;
          description "Established state";
        }
      }
      description "Session states";
    }

    grouping VPDN-HISTORY-ENTRY {
      description "VPDN history data";
      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";
      }
    }  // grouping VPDN-HISTORY-ENTRY

    grouping VPDN-REDUNDANCY {
      description "vpdn redundancy";
      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";
      }
    }  // grouping VPDN-REDUNDANCY

    grouping L2TP-NSR-QAD-STATS-RECV {
      description
        "L2TP NSR QAD receive statistics";
      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";
      }
    }  // grouping L2TP-NSR-QAD-STATS-RECV

    grouping L2TP-NSR-QAD-STATS-SEND {
      description
        "L2TP NSR QAD send statistics";
      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";
      }
    }  // grouping L2TP-NSR-QAD-STATS-SEND

    grouping VPDN-MIRRORING-STATS {
      description "VPDN mirroring stats";
      container qad-send-stats {
        description "qad send stats";
        uses L2TP-NSR-QAD-STATS-SEND;
      }  // container qad-send-stats

      container qad-recv-stats {
        description "qad recv stats";
        uses L2TP-NSR-QAD-STATS-RECV;
      }  // container qad-recv-stats

      container qad-send-stats-last-clear {
        description
          "qad send stats last clear";
        uses L2TP-NSR-QAD-STATS-SEND;
      }  // container qad-send-stats-last-clear

      container qad-recv-stats-last-clear {
        description
          "qad recv stats last clear";
        uses L2TP-NSR-QAD-STATS-RECV;
      }  // 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";
      }
    }  // grouping VPDN-MIRRORING-STATS

    grouping VPDN-LSG-NODE {
      description "VPDN LSG member";
      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";
      }
    }  // grouping VPDN-LSG-NODE

    grouping VPDN-VPN-ID {
      description "VPDN ID";
      leaf oui {
        type uint32;
        description "OUI";
      }

      leaf index {
        type uint32;
        description "Index";
      }
    }  // grouping VPDN-VPN-ID

    grouping VPDN-CONFIG {
      description
        "VPDN user configuration data";
      container vpn-id {
        description "VPN ID";
        uses VPDN-VPN-ID;
      }  // 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";
      }
    }  // grouping VPDN-CONFIG

    grouping VPDN-SUBSCRIBER {
      description
        "VPDN session 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";
      }
    }  // grouping VPDN-SUBSCRIBER

    grouping VPDN-L2TP {
      description "VPDN session 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";
      }
    }  // grouping VPDN-L2TP

    grouping VPDN-EDM-SHOW-SESSION-BR {
      description
        "VPDN session brief information";
      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";
      }
    }  // grouping VPDN-EDM-SHOW-SESSION-BR

    grouping VPDN-EDM-SHOW-SESSION-DET {
      description "VPDN session detail";
      container session {
        description "Session data";
        uses VPDN-EDM-SHOW-SESSION-BR;
      }  // container session

      container l2tp {
        description "L2TP data";
        uses VPDN-L2TP;
      }  // container l2tp

      container subscriber {
        description "Subscriber data";
        uses VPDN-SUBSCRIBER;
      }  // container subscriber

      container configuration {
        description "Configuration data";
        uses VPDN-CONFIG;
      }  // 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";
      }
    }  // grouping VPDN-EDM-SHOW-SESSION-DET
  }  // submodule Cisco-IOS-XR-tunnel-vpdn-oper-sub1