submodule Cisco-IOS-XR-aaa-protocol-radius-oper-sub2 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-aaa-protocol-radius-oper {
        prefix
          Cisco-IOS-XR-aaa-protocol-radius-oper;
    }

    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 aaa-protocol-radius package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-02-23" {
      description
        "Adding yang support for coa
       2020-10-13
         Adding yang support for new cli";
    }

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

    revision "2017-11-13" {
      description
        "Adding yang support for new cli.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

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

    semver:module-version "1.1.0";
    semver:module-version "1.0.1";

    grouping RADIUS-DYNAMIC-SERVER {
      description
        "RADIUS dynamic author server";
      leaf disconnected-invalid-requests {
        type uint32;
        description
          "Invalid disconnected requests";
      }

      leaf invalid-coa-requests {
        type uint32;
        description
          "Invalid change of authorization requests";
      }

      leaf radius-context-not-found {
        type uint32;
        description
          "Radius context not found";
      }

      leaf client-context-not-found {
        type uint32;
        description
          "Client context not found";
      }
    }  // grouping RADIUS-DYNAMIC-SERVER

    grouping RADIUS-GROUPS-SERVERS {
      description "RADIUS server groups";
      leaf groups {
        type uint32;
        description "Number of groups";
      }

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

      leaf dead-time {
        type uint32;
        units "minute";
        description "Dead time in minutes";
      }

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

      list server-group {
        description "Server groups";
        uses RADIUS-SERVER-GROUP-DATA;
      }  // list server-group
    }  // grouping RADIUS-GROUPS-SERVERS

    grouping RADIUS-DYNAMIC-CLIENT {
      description "RADIUS dynamic clients";
      list dynamic-author-client {
        description
          "List of dynamic author clients";
        uses RADIUS-DYNAMIC-CLIENT-DATA;
      }  // list dynamic-author-client
    }  // grouping RADIUS-DYNAMIC-CLIENT

    grouping RADIUS-ACCOUNTING {
      description "RADIUS accounting";
      container accounting {
        description "Accounting data";
        uses RADIUS-ACCOUNTING-DATA;
      }  // container accounting

      leaf port {
        type uint32;
        description "Accounting port number";
      }

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

      leaf family {
        type string;
        description "IP address Family";
      }
    }  // grouping RADIUS-ACCOUNTING

    grouping RADIUS-SERVER-ACCOUNTING {
      description
        "RADIUS accounting information of all servers";
      list accounting-group {
        description
          "List of accounting groups";
        uses RADIUS-ACCOUNTING;
      }  // list accounting-group
    }  // grouping RADIUS-SERVER-ACCOUNTING

    grouping RADIUS-AUTHENTICATION {
      description "RADIUS authentication";
      container authentication {
        description "Authentication data";
        uses RADIUS-AUTHENTICATION-DATA;
      }  // container authentication

      leaf port {
        type uint32;
        description
          "Authentication port number";
      }

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

      leaf family {
        type string;
        description "IP address Family";
      }
    }  // grouping RADIUS-AUTHENTICATION

    grouping RADIUS-SERVER-AUTHENTICATION {
      description
        "RADIUS authentication data of all servers";
      list authentication-group {
        description
          "List of authentication groups";
        uses RADIUS-AUTHENTICATION;
      }  // list authentication-group
    }  // grouping RADIUS-SERVER-AUTHENTICATION

    grouping RADIUS-DYNAMIC-CLIENT-DATA {
      description
        "RADIUS dynamic authorization client";
      leaf disc-reqs {
        type uint32;
        description
          "Number of RADIUS Disconnect-Requestsreceived
         from the client";
      }

      leaf disc-acks {
        type uint32;
        description
          "Number of RADIUS Disconnect-ACKs sent to the
         client";
      }

      leaf disc-naks {
        type uint32;
        description
          "Number of RADIUS Disconnect-NAKs sent to the
         client";
      }

      leaf disc-bad-auth {
        type uint32;
        description
          "Number of RADIUS Disconnect-Requests received
         from the client containing an invalid
         Authenticator";
      }

      leaf drop-disc-reqs {
        type uint32;
        description
          "Number of RADIUS Disconnect-Requests received
         from the client that were silently discarded";
      }

      leaf coa-reqs {
        type uint32;
        description
          "Number of RADIUS CoA-Requests received from the
         client";
      }

      leaf coa-acks {
        type uint32;
        description
          "Number of RADIUS CoA-ACKs sent to the client";
      }

      leaf coa-naks {
        type uint32;
        description
          "Number of RADIUS CoA-NAKs sent to the client";
      }

      leaf coa-bad-auth {
        type uint32;
        description
          "Number of RADIUS CoA-Requests received from the
         client containing an invalid Authenticator";
      }

      leaf drop-coa-reqs {
        type uint32;
        description
          "Number of RADIUS CoA-Requests received from the
         client that were silently discarded";
      }

      leaf unknown-types {
        type uint32;
        description
          "Number of incoming packets of unknown types that
         were received from the client";
      }

      leaf internal-error {
        type uint32;
        description
          "Number of packets dropped due to internal error";
      }

      leaf pak-decode-fail {
        type uint32;
        description
          "Number of packets dropped due to failure in
         radius packet decoding";
      }

      leaf vrf-parse-fail-err {
        type uint32;
        description
          "Number of requests which encountered vrf parse
         fail error";
      }

      leaf unknown-vsa-error {
        type uint32;
        description
          "Number of requests which encountered unknown vsa
         error";
      }

      leaf send-msg-failed {
        type uint32;
        description
          "Number of response packets which failed to be
         send";
      }

      leaf radius-to-ch {
        type uint32;
        description
          "Number of requests sent to command handler";
      }

      leaf ch-to-radius {
        type uint32;
        description
          "Number of responses received from command
         handler";
      }

      leaf service-parse-fail {
        type uint32;
        description
          "Number of requests which encountered service
         parse fail error";
      }

      leaf multi-subs-error {
        type uint32;
        description
          "Number of requests which encountered multiple
         subscribers not allowed error";
      }

      leaf service-not-present {
        type uint32;
        description
          "Number of requests which has missing service
         name attribute";
      }

      leaf send-to-ch-fail {
        type uint32;
        description
          "Number of requests which failed to be sent to
         command handler";
      }

      leaf vrf-name {
        type string;
        description
          "VRF of RADIUS dynamic authorization client";
      }

      leaf client-address {
        type string;
        description "Address Buffer";
      }
    }  // grouping RADIUS-DYNAMIC-CLIENT-DATA

    grouping RADIUS-AUTHORIZATION-DATA {
      description
        "RADIUS authorization data";
      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-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 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";
      }
    }  // grouping RADIUS-AUTHORIZATION-DATA

    grouping RADIUS-AUTHENTICATION-DATA {
      description
        "RADIUS authentication data";
      leaf access-requests {
        type uint32;
        description
          "Number of access requests";
      }

      leaf pending-access-requests {
        type uint32;
        description
          "Number of pending 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 access-timeouts {
        type uint32;
        description
          "Number of access packets timed out";
      }

      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 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 rtt {
        type uint32;
        units "millisecond";
        description
          "Round trip time for authentication in
         milliseconds";
      }

      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 auth-throttled-transactions {
        type uint32;
        description
          "Estimated Throttled Authentication Transactions";
      }

      leaf auth-max-transactions {
        type uint32;
        description
          "Maximum Throttled Authentication Transactions";
      }

      leaf total-test-auth-reqs {
        type uint32;
        description
          "Automated Test Stats for authentication requests";
      }

      leaf total-test-auth-timeouts {
        type uint32;
        description
          "Automated Test Stats for authentication timeouts";
      }

      leaf total-test-auth-response {
        type uint32;
        description
          "Automated Test Stats for authentication response";
      }

      leaf total-test-auth-pending {
        type uint32;
        description
          "Automated Test Stats for authentication pending";
      }
    }  // grouping RADIUS-AUTHENTICATION-DATA

    grouping RADIUS-ACCOUNTING-DATA {
      description "RADIUS accounting data";
      leaf requests {
        type uint32;
        description
          "Number of accounting requests";
      }

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

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

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

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

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

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

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

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

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

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

      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 acct-throttled-transactions {
        type uint32;
        description
          "Estimated Throttled Accounting Transactions";
      }

      leaf acct-max-throttle-trans {
        type uint32;
        description
          "Maximum Throttled Accounting Transactions";
      }

      leaf total-test-acct-reqs {
        type uint32;
        description
          "Automated Test Stats for accounting requests";
      }

      leaf total-test-acct-timeouts {
        type uint32;
        description
          "Automated Test Stats for accounting timeouts";
      }

      leaf total-test-acct-response {
        type uint32;
        description
          "Automated Test Stats for accounting response";
      }

      leaf total-test-acct-pending {
        type uint32;
        description
          "Automated Test Stats for accounting pending";
      }
    }  // grouping RADIUS-ACCOUNTING-DATA

    grouping RADIUS-SERVER-GROUP-DATA {
      description "RADIUS server group data";
      container accounting {
        description "Accounting data";
        uses RADIUS-ACCOUNTING-DATA;
      }  // container accounting

      container authentication {
        description "Authentication data";
        uses RADIUS-AUTHENTICATION-DATA;
      }  // container authentication

      container authorization {
        description "Authorization data";
        uses RADIUS-AUTHORIZATION-DATA;
      }  // container authorization

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

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

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

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

      leaf family {
        type string;
        description "IP address Family";
      }

      leaf redirected-requests {
        type uint32;
        description "Redirected Requests";
      }
    }  // grouping RADIUS-SERVER-GROUP-DATA

    grouping RADIUS-TIME-TRIES-DATA {
      description
        "Time and tries information";
      leaf value {
        type uint32;
        description
          "Value for time or tries";
      }

      leaf is-computed {
        type boolean;
        description
          "True if computed; false if not";
      }
    }  // grouping RADIUS-TIME-TRIES-DATA

    grouping RADIUS-DEAD-CRITERIA {
      description
        "Dead criteria information";
      container time {
        description "Time in seconds";
        uses RADIUS-TIME-TRIES-DATA;
      }  // container time

      container tries {
        description "Number of tries";
        uses RADIUS-TIME-TRIES-DATA;
      }  // container tries
    }  // grouping RADIUS-DEAD-CRITERIA

    grouping RADIUS-CLIENT-XML {
      description "RADIUS client data";
      leaf unknown-authentication-responses {
        type uint32;
        description
          "Number of RADIUS access responses packets
         received from unknown addresses";
      }

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

      leaf unknown-accounting-responses {
        type uint32;
        description
          "Number of RADIUS accounting responses packets
         received from unknown addresses";
      }
    }  // grouping RADIUS-CLIENT-XML
  }  // submodule Cisco-IOS-XR-aaa-protocol-radius-oper-sub2