submodule Cisco-IOS-XR-aaa-diameter-oper-sub1 {

    yang-version 1;

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

    import ietf-yang-types {
      prefix yang;
    }
    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-diameter package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-10-19" {
      description
        "show_diameter.bag file updated with ccr_final stale in gy stats";
    }

    revision "2020-04-07" {
      description
        "show_diameter.bag file updated with CCR Update COA Disconnect in GX Stats
       2020-02-28
       class-Name NAS was commented to avoid duplicate result in XML operational data
       2020-02-13
       show_diameter.bag file was updated to included sublabel";
    }

    revision "2019-10-17" {
      description
        "Added new container for NasSession and made NasSessionId as child
       2019-09-26
       Introduced a peer-closed-reason leaf and transaction related leaves in DIAMETER-SERVERBAG grouping.
       2019-08-25
       Fixed the string length to Bounded String.";
    }

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

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

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

    semver:module-version "3.1.0";
    semver:module-version "3.0.0";
    semver:module-version "2.0.0";
    semver:module-version "1.0.0";

    typedef Peer-state-value {
      type enumeration {
        enum "state-none" {
          value 0;
          description "No Peer states";
        }
        enum "closed" {
          value 1;
          description "Peer closed";
        }
        enum "wait-connection-ack" {
          value 2;
          description "Waiting for ACK";
        }
        enum "wait-cea" {
          value 3;
          description "Waiting for CEA";
        }
        enum "state-open" {
          value 4;
          description "Peer open";
        }
        enum "closing" {
          value 5;
          description "Peer closed";
        }
        enum "suspect" {
          value 6;
          description
            "Peer in suspect state";
        }
      }
      description "Peer State Values";
    }

    typedef Who-initiated-disconnect {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "host" {
          value 1;
          description "Disconnected by host";
        }
        enum "peer" {
          value 2;
          description "Disconnected by peer";
        }
      }
      description
        "Who initiated to disconnect";
    }

    typedef Disconnect-cause {
      type enumeration {
        enum "reboot" {
          value 0;
          description
            "Disconnect caused by reboot";
        }
        enum "busy" {
          value 1;
          description
            "Disconnect due to server busy";
        }
        enum "do-not-wait-to-talk" {
          value 2;
          description
            "Disconnect as server does not want to talk";
        }
      }
      description "Disconnect cause values";
    }

    typedef Peer {
      type enumeration {
        enum "undefined" {
          value 0;
          description "Peer not defined";
        }
        enum "server" {
          value 1;
          description "Server type";
        }
      }
      description " Peer type values";
    }

    typedef Security-type-value {
      type enumeration {
        enum "security-type-none" {
          value 0;
          description "No security type";
        }
        enum "type" {
          value 1;
          description "TLS security";
        }
        enum "ipsec" {
          value 2;
          description "IPSEC security";
        }
      }
      description "Security type values";
    }

    typedef Protocol-type-value {
      type enumeration {
        enum "protocol-none" {
          value 0;
          description "No protocol used";
        }
        enum "tcp" {
          value 1;
          description "TCP protocol";
        }
      }
      description "Protocol type values";
    }

    grouping DIAMETER-GX-SESS {
      description "Gx Sess";
      leaf aaa-session-id {
        type uint32;
        description "AAA session id";
      }

      leaf diameter-session-id {
        type string;
        description "Diameter session id";
      }

      leaf request-number {
        type uint32;
        description "Request Number";
      }

      leaf session-state {
        type string;
        description "Session State";
      }

      leaf request-type {
        type string;
        description "Request Type";
      }

      leaf retry-count {
        type uint32;
        description "Gx Retry count";
      }

      leaf service-count {
        type uint32;
        description " Gx Plus Service Count";
      }

      leaf gx-plus-services {
        type string;
        description "Gx Plus Services";
      }

      leaf reavalidation-time {
        type string;
        description "Revalidation Time";
      }

      leaf mac-address {
        type yang:hex-string;
        description
          "Mac address of the subscriber session";
      }

      leaf subscriber-label {
        type uint32;
        description "Subscriber Label";
      }
    }  // grouping DIAMETER-GX-SESS

    grouping DIAMETER-GY-STATS {
      description "Gy Statistics";
      leaf ccr-init-messages {
        type uint32;
        description "CCR Initial Messages";
      }

      leaf ccr-init-failed-messages {
        type uint32;
        description
          "CCR Initial Messages Failed";
      }

      leaf ccr-init-timed-out-messages {
        type uint32;
        description
          "CCR Initial Messages Timed Out";
      }

      leaf ccr-init-retry-messages {
        type uint32;
        description
          "CCR Initial Messages retry";
      }

      leaf ccr-update-messages {
        type uint32;
        description "CCR Update Messages";
      }

      leaf ccr-update-failed-messages {
        type uint32;
        description
          "CCR Update Messages Failed";
      }

      leaf ccr-update-timed-out-messages {
        type uint32;
        description
          "CCR Update Messages Timed Out";
      }

      leaf ccr-update-retry-messages {
        type uint32;
        description
          "CCR Update Messages retry";
      }

      leaf ccr-final-messages {
        type uint32;
        description "CCR Final Messages";
      }

      leaf ccr-final-failed-messages {
        type uint32;
        description
          "CCR Final Messages Failed";
      }

      leaf ccr-final-timed-out-messages {
        type uint32;
        description
          "CCR Final Messages Timed Out";
      }

      leaf ccr-final-retry-messages {
        type uint32;
        description
          "CCR Final Messages retry";
      }

      leaf cca-init-messages {
        type uint32;
        description "CCA Initial Messages";
      }

      leaf cca-init-error-messages {
        type uint32;
        description
          "CCA Initial Messages Error";
      }

      leaf cca-update-messages {
        type uint32;
        description "CCA Update Messages";
      }

      leaf cca-update-error-messages {
        type uint32;
        description
          "CCA Update Messages Error";
      }

      leaf cca-final-messages {
        type uint32;
        description "CCA Final Messages";
      }

      leaf cca-final-error-messages {
        type uint32;
        description
          "CCA Final Messages Error";
      }

      leaf rar-received-messages {
        type uint32;
        description "RAR Received Messages";
      }

      leaf rar-received-error-messages {
        type uint32;
        description
          "RAR Received Messages Error";
      }

      leaf raa-sent-messages {
        type uint32;
        description "RAA Sent Messages";
      }

      leaf raa-sent-error-messages {
        type uint32;
        description
          "RAA Sent Messages Error";
      }

      leaf asr-received-messages {
        type uint32;
        description "ASR Received Messages";
      }

      leaf asr-received-error-messages {
        type uint32;
        description
          "ASR Received Messages Error";
      }

      leaf asa-sent-messages {
        type uint32;
        description "ASA Sent Messages";
      }

      leaf asa-sent-error-messages {
        type uint32;
        description
          "ASA Sent Messages Error";
      }

      leaf unknown-request-messages {
        type uint32;
        description
          "Unknown Request Messages";
      }

      leaf restore-sessions {
        type uint32;
        description "Restore Sessions";
      }

      leaf open-sessions {
        type uint32;
        description "Total Opened Sessions";
      }

      leaf close-sessions {
        type uint32;
        description "Total Closed Sessions";
      }

      leaf active-sessions {
        type uint32;
        description "Total Active Sessions";
      }

      leaf ccr-final-for-stale {
        type uint32;
        description "CCR Final Stale";
      }
    }  // grouping DIAMETER-GY-STATS

    grouping DIAMETER-NAS {
      description "NAS data";
      leaf aaa-session-id {
        type string;
        description "AAA session id";
      }

      leaf diameter-session-id {
        type string;
        description "Diameter session id";
      }

      leaf authentication-status {
        type uint32;
        description "Diameter AAR status";
      }

      leaf authorization-status {
        type uint32;
        description "Diameter AAR status";
      }

      leaf accounting-status {
        type uint32;
        description
          "Diameter ACR status start";
      }

      leaf accounting-status-stop {
        type uint32;
        description
          "Diameter ACR status stop";
      }

      leaf disconnect-status {
        type uint32;
        description "Diameter STR status";
      }

      leaf accounting-intrim-in-packets {
        type uint32;
        description
          "Accounting intrim packet response in";
      }

      leaf accounting-intrim-out-packets {
        type uint32;
        description
          "Accounting intrim requests packets out";
      }

      leaf method-list {
        type string;
        description
          "Method list used for authentication";
      }

      leaf server-used-list {
        type string;
        description
          "Server used for authentication";
      }

      leaf subscriber-label {
        type uint32;
        description "Subscriber Label";
      }
    }  // grouping DIAMETER-NAS

    grouping DIAMETER-GY-SESS {
      description "Gy Sess";
      leaf aaa-session-id {
        type uint32;
        description "AAA session id";
      }

      leaf parent-aaa-session-id {
        type uint32;
        description "AAA Parent session id";
      }

      leaf diameter-session-id {
        type string;
        description "Diameter session id";
      }

      leaf request-number {
        type uint32;
        description "Request Number";
      }

      leaf session-state {
        type string;
        description "Session State";
      }

      leaf request-type {
        type string;
        description "Request Type";
      }

      leaf retry-count {
        type uint32;
        description "Gy Retry count";
      }

      leaf subscriber-label {
        type uint32;
        description "Subscriber Label";
      }
    }  // grouping DIAMETER-GY-SESS

    grouping DIAMETER-NAS-SUMMARY {
      description "NAS summary";
      leaf authen-response-in-packets {
        type uint32;
        description
          "Authentication response pkt in";
      }

      leaf authen-request-out-packets {
        type uint32;
        description
          "Authentication request pkt out";
      }

      leaf authen-request-in-packets {
        type uint32;
        description
          "Authentication request from client";
      }

      leaf authen-response-out-packets {
        type uint32;
        description
          "Authentication response frwd to client";
      }

      leaf authen-success-packets {
        type uint32;
        description
          "Authentication response with success";
      }

      leaf authen-response-fail-packets {
        type uint32;
        description
          "Authentication response with failure";
      }

      leaf authorization-in-packets {
        type uint32;
        description
          "Authorization response packet in";
      }

      leaf authorization-out-packets {
        type uint32;
        description
          "Authorization request packet out";
      }

      leaf authorization-request-in-packets {
        type uint32;
        description
          "Authourization request from cleint";
      }

      leaf authorization-response-out-packets {
        type uint32;
        description
          "Authourization response frwd to client";
      }

      leaf authorization-response-success-packets {
        type uint32;
        description
          "Authentication response with success";
      }

      leaf authorization-response-fail-packets {
        type uint32;
        description
          "Authentication response with failure";
      }

      leaf accounting-response-in-packets {
        type uint32;
        description
          "Accounting packet response in";
      }

      leaf accounting-request-out-packets {
        type uint32;
        description
          "Accounting requests packets out";
      }

      leaf accounting-start-request-packets {
        type uint32;
        description
          "Accounting start request from cleint";
      }

      leaf accounting-start-response-packets {
        type uint32;
        description
          "Accounting start response forward to client";
      }

      leaf accounting-start-success-packets {
        type uint32;
        description
          "Accounting start response with success";
      }

      leaf accounting-start-failed-packets {
        type uint32;
        description
          "Accounting start response with failure";
      }

      leaf accounting-stop-response-in-packets {
        type uint32;
        description
          "Accounting stop packet response in";
      }

      leaf accounting-stop-request-out-packets {
        type uint32;
        description
          "Accounting stop requests packets out";
      }

      leaf accounting-stop-request-in-packets {
        type uint32;
        description
          "Acct stop request from cleint";
      }

      leaf accounting-stop-response-out-packets {
        type uint32;
        description
          "Acct stop response forward to client";
      }

      leaf accounting-stop-success-response-packets {
        type uint32;
        description
          "Accounting stop response with success";
      }

      leaf accounting-stop-failed-packets {
        type uint32;
        description
          "Accounting stop response with failure";
      }

      leaf accounting-intrim-response-in-packets {
        type uint32;
        description
          "Accounting interim packet response in";
      }

      leaf accounting-interim-request-out-packets {
        type uint32;
        description
          "Accounting interim requests packets out";
      }

      leaf accounting-interim-request-in-packets {
        type uint32;
        description
          "Accounting Interim request from cleint";
      }

      leaf accounting-interim-response-out-packets {
        type uint32;
        description
          "Accounting interim response frwd to client";
      }

      leaf accounting-interim-success-packets {
        type uint32;
        description
          "Accounting interim response with success";
      }

      leaf accounting-interim-failed-packets {
        type uint32;
        description
          "Accounting interim response with failure";
      }

      leaf disconnect-response-in-packets {
        type uint32;
        description
          "Disconnect response packets in";
      }

      leaf disconnect-request-out-packets {
        type uint32;
        description
          "Disconnect request pkt out";
      }

      leaf disconnect-request-in-packets {
        type uint32;
        description
          "Disconnect request from cleint";
      }

      leaf disconnect-response-out-packets {
        type uint32;
        description
          "Disconnect response forward to client";
      }

      leaf disconnect-success-response-packets {
        type uint32;
        description
          "Disconnect response with success";
      }

      leaf disconnect-failed-response-packets {
        type uint32;
        description
          "Disconnect response with failure";
      }

      leaf coa-request-in-packets {
        type uint32;
        description
          "COA/RAR Request packet in";
      }

      leaf coa-response-out-packets {
        type uint32;
        description
          "COA/RAR Response packet out";
      }

      leaf coa-request-packets {
        type uint32;
        description
          "COA request from client";
      }

      leaf coa-response-packets {
        type uint32;
        description
          "COA response forward to client";
      }

      leaf coa-success-packets {
        type uint32;
        description
          "COA response with success";
      }

      leaf coa-failed-packets {
        type uint32;
        description
          "COA response with failure";
      }

      leaf pod-in-packets {
        type uint32;
        description
          "POD/RAR Request packets in";
      }

      leaf pod-out-packets {
        type uint32;
        description
          "PAD/RAR Response packets out";
      }

      leaf pod-request-in-packets {
        type uint32;
        description
          "POD request from cleint";
      }

      leaf pod-response-out-packets {
        type uint32;
        description
          "POD response forward to client";
      }

      leaf pod-success-packets {
        type uint32;
        description
          "POD response with success";
      }

      leaf pod-failed-packets {
        type uint32;
        description
          "POD response with failure";
      }
    }  // grouping DIAMETER-NAS-SUMMARY

    grouping DIAMETER-SERVERBAG {
      description "Diameter peer stats";
      leaf peer-name {
        type string;
        description "Peer Name";
      }

      leaf peer-index {
        type uint32;
        description "Peer Index";
      }

      leaf address {
        type string;
        description
          "IPv4 or IPv6 address of DIAMETER peer";
      }

      leaf port {
        type uint32;
        description
          "Port number on which the peeris running";
      }

      leaf port-connect {
        type uint32;
        description "Local Connection port";
      }

      leaf protocol-type {
        type Protocol-type-value;
        description "Protocol Type";
      }

      leaf security-type {
        type Security-type-value;
        description
          "Security type used to transport";
      }

      leaf conn-retry-timer {
        type uint32;
        units "second";
        description
          "Connection retry timer in seconds";
      }

      leaf watchdog-timer {
        type uint32;
        units "second";
        description
          "Watch dog timer in seconds";
      }

      leaf transaction-timer {
        type uint32;
        units "second";
        description
          "Transaction timer in seconds";
      }

      leaf vrf-name {
        type string;
        description "Vrf Name";
      }

      leaf source-interface {
        type string;
        description "Source Interface";
      }

      leaf destination-host {
        type string;
        description "Destination host name";
      }

      leaf destination-realm {
        type string;
        description "Destination realm";
      }

      leaf peer-type {
        type Peer;
        description "Peer Type";
      }

      leaf firmware-revision {
        type uint32;
        description "Firmware revision";
      }

      leaf state-duration {
        type uint32;
        units "second";
        description
          "State Duration in seconds";
      }

      leaf last-disconnect-cause {
        type Disconnect-cause;
        description "Last Disconnect Reason";
      }

      leaf who-init-disconnect {
        type Who-initiated-disconnect;
        description
          "Who Initiated Disconnect";
      }

      leaf in-as-rs {
        type uint32;
        description "Incoming ASRs";
      }

      leaf out-as-rs {
        type uint32;
        description "Outgoing ASRs";
      }

      leaf in-as-as {
        type uint32;
        description "Incoming ASAs";
      }

      leaf out-as-as {
        type uint32;
        description "Outgoing ASAs";
      }

      leaf in-ac-rs {
        type uint32;
        description "Incoming ACRs";
      }

      leaf out-ac-rs {
        type uint32;
        description "Outgoing ACRs";
      }

      leaf in-ac-as {
        type uint32;
        description "Incoming ACAs";
      }

      leaf out-ac-as {
        type uint32;
        description "Outgoing ACAs";
      }

      leaf in-ce-rs {
        type uint32;
        description "Incoming CERs";
      }

      leaf out-ce-rs {
        type uint32;
        description "Outgoing CERs";
      }

      leaf in-ce-as {
        type uint32;
        description "Incoming CEAs";
      }

      leaf out-ce-as {
        type uint32;
        description "Outgoing CEAs";
      }

      leaf in-dw-rs {
        type uint32;
        description "Incoming DWRs";
      }

      leaf out-dw-rs {
        type uint32;
        description "Outgoing DWRs";
      }

      leaf in-dw-as {
        type uint32;
        description "Incoming DWAs";
      }

      leaf out-dw-as {
        type uint32;
        description "Outgoing DWAs";
      }

      leaf in-dp-rs {
        type uint32;
        description "Incoming DPRs";
      }

      leaf out-dp-rs {
        type uint32;
        description "Outgoing DPRs";
      }

      leaf in-dp-as {
        type uint32;
        description "Incoming DPAs";
      }

      leaf out-dp-as {
        type uint32;
        description "Outgoing DPAs";
      }

      leaf in-ra-rs {
        type uint32;
        description "Incoming RARs";
      }

      leaf out-ra-rs {
        type uint32;
        description "Outgoing RARs";
      }

      leaf in-ra-as {
        type uint32;
        description "Incoming RAAs";
      }

      leaf out-ra-as {
        type uint32;
        description "Outgoing RAAs";
      }

      leaf in-st-rs {
        type uint32;
        description "Incoming STRs";
      }

      leaf out-st-rs {
        type uint32;
        description "Outgoing STRs";
      }

      leaf in-st-as {
        type uint32;
        description "Incoming STAs";
      }

      leaf out-st-as {
        type uint32;
        description "Outgoing STAs";
      }

      leaf in-cc-rs {
        type uint32;
        description "Incoming CCRs";
      }

      leaf out-cc-rs {
        type uint32;
        description "Outgoing CCRs";
      }

      leaf in-cc-as {
        type uint32;
        description "Incoming CCAs";
      }

      leaf out-cc-as {
        type uint32;
        description "Outgoing CCAs";
      }

      leaf out-aa-rs {
        type uint32;
        description "Outgoing AARs";
      }

      leaf in-aa-as {
        type uint32;
        description "Incoming AAAs";
      }

      leaf malformed-requests {
        type uint32;
        description "Malformed Requests";
      }

      leaf received-proto-errors {
        type uint32;
        description
          "Protocol Error Received";
      }

      leaf sent-proto-errors {
        type uint32;
        description "Protocol Error Sent";
      }

      leaf received-transient-fails {
        type uint32;
        description
          "Transient failures Received";
      }

      leaf sent-transient-fails {
        type uint32;
        description
          "Transient failures Sent";
      }

      leaf received-permanent-fails {
        type uint32;
        description
          "Permanent Failures Received";
      }

      leaf sent-permanent-fails {
        type uint32;
        description
          "Permanent Failures Sent";
      }

      leaf transport-down {
        type uint32;
        description "Transport Down";
      }

      leaf transaction-timeout-cnt {
        type uint32;
        description
          "Transcation Timeout Counter";
      }

      leaf transaction-remove-cnt {
        type uint32;
        description
          "Transaction Remove Counter";
      }

      leaf transaction-retry-cnt {
        type uint32;
        description
          "Transaction Retry Counter";
      }

      leaf transaction-normal-cnt {
        type uint32;
        description
          "Transaction Normal Counter";
      }

      leaf transaction-sent-cnt {
        type uint32;
        description
          "Transaction transport Counter";
      }

      leaf state {
        type Peer-state-value;
        description "Peer Connection Status";
      }

      leaf peer-closed-reason {
        type string {
          length "0..255";
        }
        description "Peer Closed Reason";
      }
    }  // grouping DIAMETER-SERVERBAG

    grouping DIAMETER-PEERS {
      description "Global Diameter data";
      leaf origin-host {
        type string;
        description "Origin Host";
      }

      leaf origin-realm {
        type string;
        description "Origin Realm";
      }

      leaf source-interface {
        type string;
        description "Source Interface";
      }

      leaf tls-trustpoint {
        type string;
        description "TLS Trustpoint";
      }

      leaf conn-retry-timer {
        type uint32;
        units "second";
        description
          "Connection retry timer in seconds";
      }

      leaf watchdog-timer {
        type uint32;
        units "second";
        description
          "Watch dog timer in seconds";
      }

      leaf transaction-timer {
        type uint32;
        units "second";
        description
          "Transaction timer in seconds";
      }

      leaf peer-num {
        type uint32;
        description "Total no.of peers";
      }

      leaf trans-total {
        type uint32;
        description
          "Total number of transactions";
      }

      leaf trans-max {
        type uint32;
        description
          "Maximum number of transactions";
      }

      list peer {
        description "Peer List";
        uses DIAMETER-SERVERBAG;
      }  // list peer
    }  // grouping DIAMETER-PEERS

    grouping DIAMETER-GX {
      description "Diameter Gx stats";
      leaf is-enabled {
        type boolean;
        description "Gx state";
      }

      leaf tx-timer {
        type uint32;
        units "second";
        description
          "Gx transaction timer in seconds";
      }

      leaf retransmits {
        type uint32;
        description "Gx retransmit count";
      }
    }  // grouping DIAMETER-GX

    grouping DIAMETER-GX-STATS {
      description "Gx Statistics";
      leaf ccr-init-messages {
        type uint32;
        description "CCR Initial Messages";
      }

      leaf ccr-init-failed-messages {
        type uint32;
        description
          "CCR Initial Messages Failed";
      }

      leaf ccr-init-timed-out-messages {
        type uint32;
        description
          "CCR Initial Messages Timed Out";
      }

      leaf ccr-init-retry-messages {
        type uint32;
        description
          "CCR Initial Messages retry";
      }

      leaf ccr-update-messages {
        type uint32;
        description "CCR Update Messages";
      }

      leaf ccr-update-failed-messages {
        type uint32;
        description
          "CCR Update Messages Failed";
      }

      leaf ccr-update-timed-out-messages {
        type uint32;
        description
          "CCR Update Messages Timed Out";
      }

      leaf ccr-update-retry-messages {
        type uint32;
        description
          "CCR Update Messages retry";
      }

      leaf ccr-update-coa-disconnect-messages {
        type uint32;
        description
          "CCR Update COA disconnect for quota high usage";
      }

      leaf ccr-update-coa-disconnect-failed-message {
        type uint32;
        description
          "CCR Update COA disconnect failed for quota high
         usage";
      }

      leaf ccr-final-messages {
        type uint32;
        description "CCR Final Messages";
      }

      leaf ccr-final-failed-messages {
        type uint32;
        description
          "CCR Final Messages Failed";
      }

      leaf ccr-final-timed-out-messages {
        type uint32;
        description
          "CCR Final Messages Timed Out";
      }

      leaf ccr-final-retry-messages {
        type uint32;
        description
          "CCR Final Messages retry";
      }

      leaf cca-init-messages {
        type uint32;
        description "CCA Initial Messages";
      }

      leaf cca-init-error-messages {
        type uint32;
        description
          "CCA Initial Messages Error";
      }

      leaf cca-update-messages {
        type uint32;
        description "CCA Update Messages";
      }

      leaf cca-update-error-messages {
        type uint32;
        description
          "CCA Update Messages Error";
      }

      leaf cca-final-messages {
        type uint32;
        description "CCA Final Messages";
      }

      leaf cca-final-error-messages {
        type uint32;
        description
          "CCA Final Messages Error";
      }

      leaf rar-received-messages {
        type uint32;
        description "RAR Received Messages";
      }

      leaf rar-received-error-messages {
        type uint32;
        description
          "RAR Received Messages Error";
      }

      leaf raa-sent-messages {
        type uint32;
        description "RAA Sent Messages";
      }

      leaf raa-sent-error-messages {
        type uint32;
        description
          "RAA Sent Messages Error";
      }

      leaf asr-received-messages {
        type uint32;
        description "ASR Received Messages";
      }

      leaf asr-received-error-messages {
        type uint32;
        description
          "ASR Received Messages Error";
      }

      leaf asa-sent-messsages {
        type uint32;
        description "ASA Sent Messages";
      }

      leaf asa-sent-error-messages {
        type uint32;
        description
          "ASA Sent Messages Error";
      }

      leaf session-termination-messages {
        type uint32;
        description
          "Session Termination from server";
      }

      leaf unknown-request-messages {
        type uint32;
        description
          "Unknown Request Messages";
      }

      leaf restore-sessions {
        type uint32;
        description "Restore Sessions";
      }

      leaf open-sessions {
        type uint32;
        description "Total Opened Sessions";
      }

      leaf close-sessions {
        type uint32;
        description "Total Closed Sessions";
      }

      leaf active-sessions {
        type uint32;
        description "Total Active Sessions";
      }
    }  // grouping DIAMETER-GX-STATS

    grouping DIAMETER-GY {
      description "Diameter Gy stats";
      leaf is-enabled {
        type boolean;
        description "Gy state";
      }

      leaf tx-timer {
        type uint32;
        units "second";
        description
          "Gy transaction timer in seconds";
      }

      leaf retransmits {
        type uint32;
        description "Gy retransmit count";
      }
    }  // grouping DIAMETER-GY
  }  // submodule Cisco-IOS-XR-aaa-diameter-oper-sub1