module Cisco-IOS-XR-aaa-locald-oper {

    yang-version 1;

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

    prefix aaa-locald-oper;

    import cisco-semver {
      prefix semver;
    }

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

This module contains definitions
for the following management objects:
  aaa: AAA 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 aaa {
      config false;
      description "AAA operational data";
      container all-tasks {
        description
          "All tasks supported by system";
        leaf-list task-id {
          type String1;
          description
            "Names of available task-ids";
        }
      }  // container all-tasks

      container currentuser-detail {
        description
          "Current user specific details";
        leaf name {
          type string;
          description
            "Name of the usergroup";
        }

        leaf shelltype {
          type string;
          description "Shell-type of user";
        }

        leaf directory {
          type string;
          description "Directory of user";
        }

        leaf authenmethod {
          type int32;
          description
            "Authentication method";
        }

        leaf-list usergroup {
          type String1;
          description "Component usergroups";
        }

        leaf-list taskmap {
          type String1;
          description "Task map details";
        }
      }  // container currentuser-detail

      container task-map {
        description
          "Task map of current user";
        leaf name {
          type string;
          description
            "Name of the usergroup";
        }

        leaf shelltype {
          type string;
          description "Shell-type of user";
        }

        leaf directory {
          type string;
          description "Directory of user";
        }

        leaf authenmethod {
          type int32;
          description
            "Authentication method";
        }

        leaf-list usergroup {
          type String1;
          description "Component usergroups";
        }

        leaf-list taskmap {
          type String1;
          description "Task map details";
        }
      }  // container task-map

      container taskgroups {
        description
          "Individual taskgroups container";
        list taskgroup {
          key "name";
          description
            "Specific Taskgroup Information";
          leaf name {
            type string;
            description "Taskgroup name";
          }

          container included-task-ids {
            description "Task-ids included";
            list tasks {
              description
                "List of permitted tasks";
              leaf task-id {
                type string;
                description
                  "Name of the task-id";
              }

              leaf read {
                type boolean;
                description
                  "Is read permitted?";
              }

              leaf write {
                type boolean;
                description
                  "Is write permitted?";
              }

              leaf execute {
                type boolean;
                description
                  "Is execute permitted?";
              }

              leaf debug {
                type boolean;
                description
                  "Is debug permitted?";
              }
            }  // list tasks
          }  // container included-task-ids

          container task-map {
            description "Computed task map";
            list tasks {
              description
                "List of permitted tasks";
              leaf task-id {
                type string;
                description
                  "Name of the task-id";
              }

              leaf read {
                type boolean;
                description
                  "Is read permitted?";
              }

              leaf write {
                type boolean;
                description
                  "Is write permitted?";
              }

              leaf execute {
                type boolean;
                description
                  "Is execute permitted?";
              }

              leaf debug {
                type boolean;
                description
                  "Is debug permitted?";
              }
            }  // list tasks
          }  // container task-map
        }  // list taskgroup
      }  // container taskgroups

      container users {
        description
          "Container for individual local user information";
        list user {
          key "name";
          description
            "Specific local user information";
          leaf name {
            type string;
            description "Username";
          }

          container task-map {
            description "Computed taskmap";
            list tasks {
              description
                "List of permitted tasks";
              leaf task-id {
                type string;
                description
                  "Name of the task-id";
              }

              leaf read {
                type boolean;
                description
                  "Is read permitted?";
              }

              leaf write {
                type boolean;
                description
                  "Is write permitted?";
              }

              leaf execute {
                type boolean;
                description
                  "Is execute permitted?";
              }

              leaf debug {
                type boolean;
                description
                  "Is debug permitted?";
              }
            }  // list tasks
          }  // container task-map

          leaf admin-user {
            type boolean;
            description
              "Is admin plane user ?";
          }

          leaf first-user {
            type boolean;
            description "Is first user ?";
          }

          leaf-list usergroup {
            type String1;
            description "Member usergroups";
          }
        }  // list user
      }  // container users

      container password-policies {
        description
          "Container for individual password policy
Information";
        list password-policy {
          key "name";
          description
            "Password policy details";
          leaf name {
            type string;
            description
              "Password policy name";
          }

          container life-time {
            description
              "Lifetime of the policy";
            leaf years {
              type uint8;
              description "years";
            }

            leaf months {
              type uint8;
              description "months";
            }

            leaf days {
              type uint8;
              description "days";
            }

            leaf hours {
              type uint8;
              description "hours";
            }

            leaf mins {
              type uint8;
              description "mins";
            }

            leaf secs {
              type uint8;
              description "secs";
            }
          }  // container life-time

          container warn-interval {
            description
              "Warninterval of the policy";
            leaf years {
              type uint8;
              description "years";
            }

            leaf months {
              type uint8;
              description "months";
            }

            leaf days {
              type uint8;
              description "days";
            }

            leaf hours {
              type uint8;
              description "hours";
            }

            leaf mins {
              type uint8;
              description "mins";
            }

            leaf secs {
              type uint8;
              description "secs";
            }
          }  // container warn-interval

          container lock-out-time {
            description
              "Lockout time of the policy";
            leaf years {
              type uint8;
              description "years";
            }

            leaf months {
              type uint8;
              description "months";
            }

            leaf days {
              type uint8;
              description "days";
            }

            leaf hours {
              type uint8;
              description "hours";
            }

            leaf mins {
              type uint8;
              description "mins";
            }

            leaf secs {
              type uint8;
              description "secs";
            }
          }  // container lock-out-time

          container restrict-old-time {
            description
              "Password History validity time";
            leaf years {
              type uint8;
              description "years";
            }

            leaf months {
              type uint8;
              description "months";
            }

            leaf days {
              type uint8;
              description "days";
            }
          }  // container restrict-old-time

          leaf min-len {
            type uint8;
            description "Min Length";
          }

          leaf max-len {
            type uint8;
            description "Max Length";
          }

          leaf spl-char {
            type uint8;
            description
              "Special Character length";
          }

          leaf upper-case {
            type uint8;
            description
              "UpperCase Character length";
          }

          leaf lower-case {
            type uint8;
            description
              "LowerCase Character length";
          }

          leaf numeric {
            type uint8;
            description
              "Numeric Character length";
          }

          leaf restrict-old-count {
            type uint8;
            description
              "Password History Count";
          }

          leaf min-char-change {
            type uint8;
            description
              "Number of different characters";
          }

          leaf num-of-users {
            type uint8;
            description
              "Number of users with this policy";
          }

          leaf max-fail-attempts {
            type uint32;
            description
              "Maximum Failure Attempts allowed";
          }

          leaf usr-count {
            type uint8;
            description "Count of users";
          }

          leaf err-count {
            type uint8;
            description "Error Count";
          }

          leaf lock-out-count {
            type uint8;
            description "Lock Out Count";
          }

          leaf max-char-repetition {
            type uint8;
            description
              "Number of times a character can repeat";
          }

          leaf restrict-username {
            type Status;
            description
              "Username restriction as password";
          }

          leaf restrict-username-reverse {
            type Status;
            description
              "Reversed Username restriction as password";
          }

          leaf restrict-password-reverse {
            type Status;
            description
              "Reversed password restriction as new password";
          }

          leaf restrict-password-advanced {
            type Status;
            description
              "Advanced restriction on new password";
          }
        }  // list password-policy
      }  // container password-policies

      container usergroups {
        description
          "Container for individual usergroup Information";
        list usergroup {
          key "name";
          description
            "Specific Usergroup Information";
          leaf name {
            type string;
            description "Usergroup name";
          }

          container task-map {
            description "Computed task map";
            list tasks {
              description
                "List of permitted tasks";
              leaf task-id {
                type string;
                description
                  "Name of the task-id";
              }

              leaf read {
                type boolean;
                description
                  "Is read permitted?";
              }

              leaf write {
                type boolean;
                description
                  "Is write permitted?";
              }

              leaf execute {
                type boolean;
                description
                  "Is execute permitted?";
              }

              leaf debug {
                type boolean;
                description
                  "Is debug permitted?";
              }
            }  // list tasks
          }  // container task-map

          list taskgroup {
            description
              "Component taskgroups";
            container included-task-ids {
              description
                "Task-ids included";
              list tasks {
                description
                  "List of permitted tasks";
                leaf task-id {
                  type string;
                  description
                    "Name of the task-id";
                }

                leaf read {
                  type boolean;
                  description
                    "Is read permitted?";
                }

                leaf write {
                  type boolean;
                  description
                    "Is write permitted?";
                }

                leaf execute {
                  type boolean;
                  description
                    "Is execute permitted?";
                }

                leaf debug {
                  type boolean;
                  description
                    "Is debug permitted?";
                }
              }  // list tasks
            }  // container included-task-ids

            container task-map {
              description
                "Computed task map";
              list tasks {
                description
                  "List of permitted tasks";
                leaf task-id {
                  type string;
                  description
                    "Name of the task-id";
                }

                leaf read {
                  type boolean;
                  description
                    "Is read permitted?";
                }

                leaf write {
                  type boolean;
                  description
                    "Is write permitted?";
                }

                leaf execute {
                  type boolean;
                  description
                    "Is execute permitted?";
                }

                leaf debug {
                  type boolean;
                  description
                    "Is debug permitted?";
                }
              }  // list tasks
            }  // container task-map
          }  // list taskgroup
        }  // list usergroup
      }  // container usergroups

      container authen-method {
        description
          "Current users authentication method";
        leaf name {
          type string;
          description
            "Name of the usergroup";
        }

        leaf shelltype {
          type string;
          description "Shell-type of user";
        }

        leaf directory {
          type string;
          description "Directory of user";
        }

        leaf authenmethod {
          type int32;
          description
            "Authentication method";
        }

        leaf-list usergroup {
          type String1;
          description "Component usergroups";
        }

        leaf-list taskmap {
          type String1;
          description "Task map details";
        }
      }  // container authen-method

      container current-usergroup {
        description
          "Specific Usergroup Information";
        leaf name {
          type string;
          description
            "Name of the usergroup";
        }

        leaf shelltype {
          type string;
          description "Shell-type of user";
        }

        leaf directory {
          type string;
          description "Directory of user";
        }

        leaf authenmethod {
          type int32;
          description
            "Authentication method";
        }

        leaf-list usergroup {
          type String1;
          description "Component usergroups";
        }

        leaf-list taskmap {
          type String1;
          description "Task map details";
        }
      }  // container current-usergroup

      container radius {
        description
          "RADIUS operational data";
        container servers {
          description
            "List of RADIUS servers configured";
          list server {
            description "RADIUS Server";
            leaf ip-address {
              type inet:ip-address-no-zone;
              description
                "IP address of RADIUS server";
            }

            leaf auth-port-number {
              type Aaa-radius-port-range;
              description
                "Authentication Port number (standard port
1645)";
            }

            leaf acct-port-number {
              type Aaa-radius-port-range;
              description
                "Accounting Port number (standard port 1646)";
            }

            leaf ipv4-address {
              type inet:ipv4-address;
              description
                "IP address of RADIUS server";
            }

            leaf priority {
              type uint32;
              description
                "A number that indicates the priority of the
server";
            }

            leaf timeout-xr {
              type uint32;
              units "second";
              description
                "Per-server timeout in seconds";
            }

            leaf retransmit {
              type uint32;
              description
                "Per-server retransmit";
            }

            leaf dead-time {
              type uint32;
              units "minute";
              description
                "Per-server deadtime in minutes";
            }

            leaf dead-detect-time {
              type uint32;
              units "second";
              description
                "Per-server dead-detect time in  seconds";
            }

            leaf dead-detect-tries {
              type uint32;
              description
                "Per-server dead-detect tries";
            }

            leaf authentication-port {
              type uint32;
              description
                "Authentication port";
            }

            leaf accounting-port {
              type uint32;
              description "Accounting port";
            }

            leaf state {
              type string;
              description
                "State of the server UP/DOWN";
            }

            leaf current-state-duration {
              type uint32;
              description
                "Elapsed time the server has been in current
state";
            }

            leaf previous-state-duration {
              type uint32;
              description
                "Elapsed time the server was been in previous
state";
            }

            leaf packets-in {
              type uint32;
              description
                "Total number of incoming packets read";
            }

            leaf packets-out {
              type uint32;
              description
                "Total number of outgoing packets sent";
            }

            leaf timeouts {
              type uint32;
              description
                "Total number of packets timed-out";
            }

            leaf aborts {
              type uint32;
              description
                "Total number of requests aborted";
            }

            leaf replies-expected {
              type uint32;
              description
                "Number of replies expected to arrive";
            }

            leaf redirected-requests {
              type uint32;
              description
                "Number of requests redirected";
            }

            leaf authentication-rtt {
              type uint32;
              units "millisecond";
              description
                "Round-trip time for authentication in
milliseconds";
            }

            leaf access-requests {
              type uint32;
              description
                "Number of access requests";
            }

            leaf access-request-retransmits {
              type uint32;
              description
                "Number of retransmitted access requests";
            }

            leaf access-accepts {
              type uint32;
              description
                "Number of access accepts";
            }

            leaf access-rejects {
              type uint32;
              description
                "Number of access rejects";
            }

            leaf access-challenges {
              type uint32;
              description
                "Number of access challenges";
            }

            leaf bad-access-responses {
              type uint32;
              description
                "Number of bad access responses";
            }

            leaf bad-access-authenticators {
              type uint32;
              description
                "Number of bad access authenticators";
            }

            leaf pending-access-requests {
              type uint32;
              description
                "Number of pending access requests";
            }

            leaf access-timeouts {
              type uint32;
              description
                "Number of access packets timed-out";
            }

            leaf unknown-access-types {
              type uint32;
              description
                "Number of packets received with unknown type
from authentication server";
            }

            leaf dropped-access-responses {
              type uint32;
              description
                "Number of access responses dropped";
            }

            leaf throttled-access-reqs {
              type uint32;
              description
                "No of throttled access reqs stats";
            }

            leaf throttled-timed-out-reqs {
              type uint32;
              description
                "No of access reqs that is throttled is timedout";
            }

            leaf throttled-dropped-reqs {
              type uint32;
              description
                "No of discarded access reqs";
            }

            leaf max-throttled-access-reqs {
              type uint32;
              description
                "Max throttled access reqs";
            }

            leaf currently-throttled-access-reqs {
              type uint32;
              description
                "No of currently throttled access reqs";
            }

            leaf authen-response-time {
              type uint32;
              description
                "Average response time for authentication
requests";
            }

            leaf authen-transaction-successess {
              type uint32;
              description
                "Number of succeeded authentication transactions";
            }

            leaf authen-transaction-failure {
              type uint32;
              description
                "Number of failed authentication transactions";
            }

            leaf authen-unexpected-responses {
              type uint32;
              description
                "Number of unexpected authentication responses";
            }

            leaf authen-server-error-responses {
              type uint32;
              description
                "Number of server error authentication responses";
            }

            leaf authen-incorrect-responses {
              type uint32;
              description
                "Number of incorrect authentication responses";
            }

            leaf author-requests {
              type uint32;
              description
                "Number of access requests";
            }

            leaf author-request-timeouts {
              type uint32;
              description
                "Number of access packets timed out";
            }

            leaf author-response-time {
              type uint32;
              description
                "Average response time for authorization requests";
            }

            leaf author-transaction-successess {
              type uint32;
              description
                "Number of succeeded authorization transactions";
            }

            leaf author-transaction-failure {
              type uint32;
              description
                "Number of failed authorization transactions";
            }

            leaf author-unexpected-responses {
              type uint32;
              description
                "Number of unexpected authorization responses";
            }

            leaf author-server-error-responses {
              type uint32;
              description
                "Number of server error authorization responses";
            }

            leaf author-incorrect-responses {
              type uint32;
              description
                "Number of incorrect authorization responses";
            }

            leaf accounting-rtt {
              type uint32;
              units "millisecond";
              description
                "Round-trip time for accounting in milliseconds";
            }

            leaf accounting-requests {
              type uint32;
              description
                "Number of accounting requests";
            }

            leaf accounting-retransmits {
              type uint32;
              description
                "Number of retransmitted accounting requests";
            }

            leaf accounting-responses {
              type uint32;
              description
                "Number of accounting responses";
            }

            leaf bad-accounting-responses {
              type uint32;
              description
                "Number of bad accounting responses";
            }

            leaf bad-accounting-authenticators {
              type uint32;
              description
                "Number of bad accounting authenticators";
            }

            leaf pending-accounting-requets {
              type uint32;
              description
                "Number of pending accounting requests";
            }

            leaf accounting-timeouts {
              type uint32;
              description
                "Number of accounting packets timed-out";
            }

            leaf unknown-accounting-types {
              type uint32;
              description
                "Number of packets received with unknown type
from accounting server";
            }

            leaf dropped-accounting-responses {
              type uint32;
              description
                "Number of accounting responses dropped";
            }

            leaf is-a-private-server {
              type boolean;
              description
                "Is a private server";
            }

            leaf total-test-auth-reqs {
              type uint32;
              description
                "Total auth test request";
            }

            leaf total-test-auth-timeouts {
              type uint32;
              description
                "Total auth test timeouts";
            }

            leaf total-test-auth-response {
              type uint32;
              description
                "Total auth test response";
            }

            leaf total-test-auth-pending {
              type uint32;
              description
                "Total auth test pending";
            }

            leaf total-test-acct-reqs {
              type uint32;
              description
                " Total acct test req";
            }

            leaf total-test-acct-timeouts {
              type uint32;
              description
                "Total acct test timeouts";
            }

            leaf total-test-acct-response {
              type uint32;
              description
                "Total acct test response";
            }

            leaf total-test-acct-pending {
              type uint32;
              description
                "Total acct test pending";
            }

            leaf throttled-acct-transactions {
              type uint32;
              description
                "No of throttled acct transactions stats";
            }

            leaf throttled-acct-timed-out-stats {
              type uint32;
              description
                "No of acct transaction that is throttled is
timedout";
            }

            leaf throttled-acct-failures-stats {
              type uint32;
              description
                "No of acct discarded transaction";
            }

            leaf max-acct-throttled {
              type uint32;
              description
                "Max throttled acct transactions";
            }

            leaf throttleda-acct-transactions {
              type uint32;
              description
                "No of currently throttled acct transactions";
            }

            leaf acct-unexpected-responses {
              type uint32;
              description
                "Number of unexpected accounting responses";
            }

            leaf acct-server-error-responses {
              type uint32;
              description
                "Number of server error accounting responses";
            }

            leaf acct-incorrect-responses {
              type uint32;
              description
                "Number of incorrect accounting responses";
            }

            leaf acct-response-time {
              type uint32;
              description
                "Average response time for authentication
requests";
            }

            leaf acct-transaction-successess {
              type uint32;
              description
                "Number of succeeded authentication transactions";
            }

            leaf acct-transaction-failure {
              type uint32;
              description
                "Number of failed authentication transactions";
            }

            leaf total-deadtime {
              type uint32;
              description
                "Total time of Server being in DEAD state";
            }

            leaf last-deadtime {
              type uint32;
              description
                "Time of Server being in DEAD state, after last
UP";
            }

            leaf is-quarantined {
              type boolean;
              description
                "flag to indicate Server is quarantined or not
(Automated TEST in progress)";
            }

            leaf group-name {
              type string;
              description
                "Server group name for private server";
            }

            leaf ip-address-xr {
              type string;
              description
                "IP address buffer";
            }

            leaf family {
              type string;
              description
                "IP address Family";
            }
          }  // list server
        }  // container servers

        container radius-source-interface {
          description
            "RADIUS source interfaces";
          list list-of-source-interface {
            description
              "List of source interfaces";
            leaf interface-name {
              type string;
              description
                "Name of the source interface";
            }

            leaf ipaddrv4 {
              type string;
              description
                "IP address buffer";
            }

            leaf ipaddrv6 {
              type string;
              description
                "IP address buffer";
            }

            leaf vrfid {
              type uint32;
              description "VRF Id";
            }
          }  // list list-of-source-interface
        }  // container radius-source-interface

        container global {
          description
            "RADIUS Client Information";
          leaf unknown-authentication-response {
            type uint32;
            description
              "Number of RADIUS Access-Response packets
received from unknown addresses";
          }

          leaf authentication-nas-id {
            type string;
            description
              "NAS-Identifier of the RADIUS authentication
client";
          }

          leaf unknown-accounting-response {
            type uint32;
            description
              "Number of RADIUS Accounting-Response packets
received from unknown addresses";
          }

          leaf accounting-nas-id {
            type string;
            description
              "NAS-Identifier of the RADIUS accounting client";
          }
        }  // container global
      }  // container radius

      container tacacs {
        description
          "TACACS operational data";
        container requests {
          description
            "TACACS Active Request List";
          list request {
            description "request";
            list tacacs-requestbag {
              description
                "address in tacascd proc space of this req";
              leaf time-remaining {
                type uint32;
                description
                  "time remaining for this request";
              }

              leaf bytes-out {
                type uint32;
                units "byte";
                description "bytes written";
              }

              leaf out-pak-size {
                type uint32;
                description
                  "size of the packet to be sent";
              }

              leaf bytes-in {
                type uint32;
                units "byte";
                description
                  "bytes read from socket";
              }

              leaf in-pak-size {
                type uint32;
                description
                  "size of the packet to be received";
              }

              leaf pak-type {
                type string;
                description
                  "the type of packet";
              }

              leaf session-id {
                type int32;
                description
                  "same as in pkt hdr";
              }

              leaf sock {
                type int32;
                description "socket number";
              }
            }  // list tacacs-requestbag
          }  // list request
        }  // container requests

        container servers {
          description
            "TACACS server Information";
          list server {
            description "server";
            leaf addr {
              type inet:ipv4-address;
              description
                "internet address of T+ server";
            }

            leaf timeout {
              type uint32;
              description
                "per-server timeout";
            }

            leaf port {
              type uint32;
              description
                "per server port to use";
            }

            leaf bytes-in {
              type uint32;
              units "byte";
              description "# of bytes read";
            }

            leaf bytes-out {
              type uint32;
              units "byte";
              description "# of bytes out";
            }

            leaf closes {
              type uint32;
              description "socket closes";
            }

            leaf opens {
              type uint32;
              description "socket opens";
            }

            leaf errors {
              type uint32;
              description "error count";
            }

            leaf aborts {
              type uint32;
              description "abort count";
            }

            leaf paks-in {
              type uint32;
              description
                "# of incoming packets read";
            }

            leaf paks-out {
              type uint32;
              description
                "# of outgoing packets sent";
            }

            leaf replies-expected {
              type uint32;
              description
                "# of replies expected to arrive";
            }

            leaf up {
              type boolean;
              description
                "is the server UP or down ?";
            }

            leaf conn-up {
              type boolean;
              description
                "is the server connected ?";
            }

            leaf single-connect {
              type boolean;
              description
                "is this a single connect server ?";
            }

            leaf is-private {
              type boolean;
              description
                "is this a private server ?";
            }

            leaf vrf-name {
              type string {
                length "0..33";
              }
              description
                "VRF in which server is reachable";
            }

            leaf addr-buf {
              type string {
                length "0..46";
              }
              description
                "IP address buffer";
            }

            leaf family {
              type string {
                length "0..5";
              }
              description
                "IP address Family";
            }

            leaf single-connect-idle-timeout {
              type uint32;
              description
                "Single connection idle timeout";
            }

            leaf connection-attempted {
              type int64;
              description
                "last attempted contact time";
            }
          }  // list server
        }  // container servers

        container server-groups {
          description
            "TACACS sg Information";
          list server-group {
            description "server group";
            leaf group-name {
              type string;
              description
                "name of the server group";
            }

            leaf sg-map-num {
              type uint32;
              description
                "server group mapped number";
            }

            leaf vrf-name {
              type string {
                length "0..33";
              }
              description "vrf of the group";
            }

            list server {
              description
                "list of servers in this group";
              leaf addr {
                type inet:ipv4-address;
                description
                  "internet address of T+ server";
              }

              leaf timeout {
                type uint32;
                description
                  "per-server timeout";
              }

              leaf port {
                type uint32;
                description
                  "per server port to use";
              }

              leaf bytes-in {
                type uint32;
                units "byte";
                description
                  "# of bytes read";
              }

              leaf bytes-out {
                type uint32;
                units "byte";
                description "# of bytes out";
              }

              leaf closes {
                type uint32;
                description "socket closes";
              }

              leaf opens {
                type uint32;
                description "socket opens";
              }

              leaf errors {
                type uint32;
                description "error count";
              }

              leaf aborts {
                type uint32;
                description "abort count";
              }

              leaf paks-in {
                type uint32;
                description
                  "# of incoming packets read";
              }

              leaf paks-out {
                type uint32;
                description
                  "# of outgoing packets sent";
              }

              leaf replies-expected {
                type uint32;
                description
                  "# of replies expected to arrive";
              }

              leaf up {
                type boolean;
                description
                  "is the server UP or down ?";
              }

              leaf conn-up {
                type boolean;
                description
                  "is the server connected ?";
              }

              leaf single-connect {
                type boolean;
                description
                  "is this a single connect server ?";
              }

              leaf is-private {
                type boolean;
                description
                  "is this a private server ?";
              }

              leaf vrf-name {
                type string {
                  length "0..33";
                }
                description
                  "VRF in which server is reachable";
              }

              leaf addr-buf {
                type string {
                  length "0..46";
                }
                description
                  "IP address buffer";
              }

              leaf family {
                type string {
                  length "0..5";
                }
                description
                  "IP address Family";
              }

              leaf single-connect-idle-timeout {
                type uint32;
                description
                  "Single connection idle timeout";
              }

              leaf connection-attempted {
                type int64;
                description
                  "last attempted contact time";
              }
            }  // list server
          }  // list server-group
        }  // container server-groups
      }  // container tacacs
    }  // container aaa
  }  // module Cisco-IOS-XR-aaa-locald-oper