submodule Cisco-IOS-XR-iedge4710-oper-sub2 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-iedge4710-oper {
        prefix Cisco-IOS-XR-iedge4710-oper;
    }

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

    organization "Cisco Systems, Inc.";

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

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR iedge4710 package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-12-24" {
      description
        "Updated acct stop internal stats.
       2020-11-21
         Added statsd event to session export.
       2020-11-02
         Added yang paths to support ADT
       2020-10-23
         Added disc queue statistics.
       2020-10-09
         Added acct stop statistics.
       2020-08-24
         Added Feature ID to session export.";
    }

    revision "2020-02-20" {
      description
        "Added FADB statistics.
       2020-01-04
       Added disconnect history support.";
    }

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

    revision "2018-09-20" {
      description "Fixed yang gaps.";
    }

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

    semver:module-version "3.0.0";
    semver:module-version "2.0.0";
    semver:module-version "1.0.1";

    typedef Iedge-oper-service-status {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "error" {
          value 1;
          description "Error";
        }
        enum "new" {
          value 2;
          description "New";
        }
        enum "loading" {
          value 3;
          description "Loading";
        }
        enum "req-association" {
          value 4;
          description "Request Association";
        }
        enum "associated" {
          value 5;
          description "Associated";
        }
        enum "req-pd-association" {
          value 6;
          description
            "Request PD Association";
        }
        enum "applied" {
          value 7;
          description "Applied";
        }
        enum "req-unassociation" {
          value 8;
          description
            "Request Unassociation";
        }
        enum "req-pd-unassociation" {
          value 9;
          description
            "Request PD Unassociation";
        }
        enum "unapplied" {
          value 10;
          description "Unapplied";
        }
        enum "max" {
          value 11;
          description "Max";
        }
      }
      description
        "Subscriber service status";
    }

    typedef Iedge-oper-service {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown Service";
        }
        enum "profile" {
          value 1;
          description "Profile";
        }
        enum "template" {
          value 2;
          description "Template";
        }
        enum "grp-template" {
          value 3;
          description "GRP Template";
        }
        enum "ppp-template" {
          value 4;
          description "PPP Template";
        }
        enum "eth-template" {
          value 5;
          description "ETH Template";
        }
        enum "ip-sub-template" {
          value 6;
          description "IPSub Template";
        }
        enum "multi-template" {
          value 7;
          description "Multi Template";
        }
        enum "max-templae" {
          value 8;
          description "MAX Template";
        }
      }
      description "Service types";
    }

    typedef Iedge-oper-session-state {
      type enumeration {
        enum "initialize" {
          value 0;
          description "Initialize";
        }
        enum "connecting" {
          value 1;
          description "Connecting";
        }
        enum "connected" {
          value 2;
          description "Connected";
        }
        enum "activated" {
          value 3;
          description "Activated";
        }
        enum "idle" {
          value 4;
          description "Idle";
        }
        enum "disconnecting" {
          value 5;
          description "Disconnecting";
        }
        enum "end" {
          value 6;
          description "End";
        }
      }
      description
        "Subscriber session states";
    }

    typedef Mac-address {
      type yang:mac-address;
      description "MAC address type";
    }

    typedef Hex-binary {
      type yang:hex-string;
      description "Hex binary data";
    }

    typedef Ipv4-address {
      type inet:ipv4-address;
      description "IP address type";
    }

    typedef Iedge-ppp-sub {
      type enumeration {
        enum "pta" {
          value 0;
          description
            "PPP termination and aggregation";
        }
        enum "lac" {
          value 1;
          description
            "L2TP access controller";
        }
      }
      description "PPPoE sub types";
    }

    typedef Iedge-oper-session {
      type enumeration {
        enum "unknown" {
          value 0;
          description "Unknown";
        }
        enum "pppoe" {
          value 1;
          description "PPPoE/PPP client";
        }
        enum "ppp" {
          value 2;
          description "PPP serial client";
        }
        enum "ip-packet-trigger" {
          value 3;
          description
            "IP subscriber - packet trigger";
        }
        enum "ip-packet-dhcp-trigger" {
          value 4;
          description
            "IP subscriber - DHCP trigger";
        }
      }
      description "Subscriber session types";
    }

    grouping SUBSCRIBER-SESSION-AF-COUNTS {
      description
        "Subscriber address family session counts";
      leaf in-progress-sessions {
        type uint32;
        description
          "Sessions with undecided address family";
      }

      leaf ipv4-only-sessions {
        type uint32;
        description "IPv4 only sessions ";
      }

      leaf ipv6-only-sessions {
        type uint32;
        description "IPv6 only sessions ";
      }

      leaf dual-part-up-sessions {
        type uint32;
        description
          "Dual stack partially up sessions";
      }

      leaf dual-up-sessions {
        type uint32;
        description "Dual stack up sessions";
      }

      leaf lac-sessions {
        type uint32;
        description "LAC sessions";
      }
    }  // grouping SUBSCRIBER-SESSION-AF-COUNTS

    grouping SUBSCRIBER-SESSION-AF-SUMMARY {
      description
        "Subscriber session address family summary
       information";
      container pppoe {
        description "PPPoE summary";
        uses SUBSCRIBER-SESSION-AF-COUNTS;
      }  // container pppoe

      container ip-subscriber-dhcp {
        description
          "IP subscriber DHCP summary";
        uses SUBSCRIBER-SESSION-AF-COUNTS;
      }  // container ip-subscriber-dhcp

      container ip-subscriber-packet {
        description
          "IP subscriber packet summary";
        uses SUBSCRIBER-SESSION-AF-COUNTS;
      }  // container ip-subscriber-packet
    }  // grouping SUBSCRIBER-SESSION-AF-SUMMARY

    grouping SUBSCRIBER-SESSION-STATE-COUNTS {
      description
        "Subscriber state session counts";
      leaf initialized-sessions {
        type uint32;
        description
          "Sessions in initialized state";
      }

      leaf connecting-sessions {
        type uint32;
        description
          "Sessions in connecting state";
      }

      leaf connected-sessions {
        type uint32;
        description
          "Sessions in connected state";
      }

      leaf activated-sessions {
        type uint32;
        description
          "Sessions in activated state";
      }

      leaf idle-sessions {
        type uint32;
        description "Sessions in idle state";
      }

      leaf disconnecting-sessions {
        type uint32;
        description
          "Sessions in disconnecting state";
      }

      leaf end-sessions {
        type uint32;
        description "Sessions in end state";
      }
    }  // grouping SUBSCRIBER-SESSION-STATE-COUNTS

    grouping SUBSCRIBER-SESSION-STATE-SUMMARY {
      description
        "Subscriber session state summary information";
      container pppoe {
        description "PPPoE summary";
        uses SUBSCRIBER-SESSION-STATE-COUNTS;
      }  // container pppoe

      container ip-subscriber-dhcp {
        description
          "IP subscriber DHCP summary";
        uses SUBSCRIBER-SESSION-STATE-COUNTS;
      }  // container ip-subscriber-dhcp

      container ip-subscriber-packet {
        description
          "IP subscriber packet summary";
        uses SUBSCRIBER-SESSION-STATE-COUNTS;
      }  // container ip-subscriber-packet
    }  // grouping SUBSCRIBER-SESSION-STATE-SUMMARY

    grouping SUBSCRIBER-SESSION-SUMMARY {
      description
        "Subscriber session summary information";
      container state-xr {
        description "State summary";
        uses SUBSCRIBER-SESSION-STATE-SUMMARY;
      }  // container state-xr

      container address-family-xr {
        description "Address family summary";
        uses SUBSCRIBER-SESSION-AF-SUMMARY;
      }  // container address-family-xr
    }  // grouping SUBSCRIBER-SESSION-SUMMARY

    grouping IEDGE-STATS-SRG-DATA {
      description
        "Geo Redundancy statistics";
      leaf txlist-send-triggered {
        type uint32;
        description "Txlist Send Triggered";
      }

      leaf txlist-send-failed {
        type uint32;
        description "Txlist Send Failed";
      }

      leaf txlist-send-failed-notactive {
        type uint32;
        description
          "Txlist send failed due to not active";
      }

      leaf actual-txlist-sent {
        type uint32;
        description "Txlist Send Success";
      }

      leaf alreadyin-txlist {
        type uint32;
        description
          "Element already in Txlist";
      }

      leaf txlist-encode {
        type uint32;
        description "Txlist Encode";
      }

      leaf txlist-encode-fail {
        type uint32;
        description "Txlist encode Failed";
      }

      leaf create-update-encode {
        type uint32;
        description
          "Txlist Create Update Encode";
      }

      leaf delete-encode {
        type uint32;
        description "Txlist Delete Encode";
      }

      leaf create-upd-clean-callback {
        type uint32;
        description
          "Txlist Create/update clean callback";
      }

      leaf delete-clean-callback {
        type uint32;
        description
          "Txlist Delete clean callback";
      }

      leaf slave-recv-entry {
        type uint32;
        description "Slave Recieved Sync";
      }

      leaf slave-decode-fail {
        type uint32;
        description "Decode failed on Slave";
      }

      leaf slave-create-update {
        type uint32;
        description
          "Create Update received on slave";
      }

      leaf slave-delete {
        type uint32;
        description
          "Delete received on slave";
      }

      leaf srg-context-malloc {
        type uint32;
        description "SRG context allocated";
      }

      leaf srg-context-free {
        type uint32;
        description "SRG context freed";
      }

      leaf sod-count {
        type uint32;
        description
          "Number of SODs Received";
      }

      leaf eod-count {
        type uint32;
        description
          "Number of EODs Received";
      }

      leaf sod-eod-replay-req-count {
        type uint32;
        description
          "Number of Replay Requests Within SOD EOD Window";
      }

      leaf sod-eod-dirty-mark-count {
        type uint32;
        description
          "Number of Sessions Marked as Invalid Within SOD
         EOD Window";
      }

      leaf sod-eod-dirty-delete-count {
        type uint32;
        description
          "Number of Sessions Invalid Deletes Within SOD
         EOD Window";
      }

      leaf ack-to-srg {
        type uint32;
        description
          "Number of ACKs sent to Srg";
      }

      leaf nack-to-srg {
        type uint32;
        description
          "Number of NACKs sent to Srg";
      }

      leaf nack-to-srg-fail-cnt {
        type uint32;
        description
          "Number of NACKs Failed to send to Srg";
      }

      leaf txlist-remove-all {
        type uint32;
        description
          "Number of Txlist remove all calls";
      }

      leaf txlist-del-sync {
        type uint32;
        description
          "Number for Txlist delete for sync msg";
      }

      leaf txlist-del-sync-notlinked {
        type uint32;
        description
          "Number of Txlist delete for sync which are not
         linked";
      }

      leaf txlist-del-app {
        type uint32;
        description
          "Number of Txlist delete for App msg";
      }

      leaf txlist-del-app-notlinked {
        type uint32;
        description
          "Number of Txlist delete for App which are not
         linked";
      }

      leaf txlist-clean-invalid-state {
        type uint32;
        description
          "Number of Txlist Cleanup called on Invalid
         subscriber srg state";
      }

      leaf txlist-remove-all-internal-error {
        type uint32;
        description
          "Number of Internal errors upon Master Txlist
         remove all call";
      }

      leaf is-srg-flow-control-enabled {
        type boolean;
        description
          "Flag indicating SRG Flow control enabled or not";
      }

      leaf max-inflight-sessoin-count {
        type uint32;
        description
          "Maximum no.of inflight sessions allowed";
      }

      leaf flow-control-resume-threshold {
        type uint32;
        description
          "Threshold Limit to resume the flow control";
      }

      leaf inflight-session-count {
        type uint32;
        description
          "No.of Sessions inflight at given time";
      }

      leaf inflight-add-count {
        type uint32;
        description
          "No.of inflight sessions added";
      }

      leaf inflight-under-run-count {
        type uint32;
        description
          "Inflight Underrun Counter";
      }

      leaf inflight-alloc-fails {
        type uint32;
        description
          "Memory Alloc Failures for Inflight Entry";
      }

      leaf inflight-insert-failures {
        type uint32;
        description
          "Inflight Entry Insert Failures";
      }

      leaf inflight-deletes {
        type uint32;
        description "Inflight Deletes Count";
      }

      leaf inflight-not-found {
        type uint32;
        description
          "Inflight Entries not found during delete";
      }

      leaf inflight-delete-failures {
        type uint32;
        description
          "Inflight Entry Delete Failures";
      }

      leaf total-pause-count {
        type uint32;
        description
          "Total No.of times Pause is Enabled";
      }

      leaf total-resume-count {
        type uint32;
        description
          "Total No.of times Resume is triggered";
      }

      leaf total-dont-send-to-txlist {
        type uint32;
        description
          "Total No of times Dont send to Txlist";
      }

      leaf total-srg-txlist-no-add-restore-flag-set {
        type uint32;
        description
          "Total No of times restore flag found set";
      }

      leaf total-srg-not-master {
        type uint32;
        description
          "Total No of times SRG Not Master";
      }

      leaf total-master-eoms-pending {
        type uint32;
        description
          "Total No of times Master EOMS Pending";
      }

      leaf total-master-eoms-pending-cleared {
        type uint32;
        description
          "Total No of times Master EOMS Pending Cleared";
      }

      leaf last-pause-period {
        type uint64;
        description
          "Amount of time paused during last flow control
         window";
      }

      leaf total-pause-time {
        type uint64;
        description
          "Total Amount of time paused during all flow
         control windows";
      }

      leaf last-pause-time {
        type uint64;
        description
          "Timestamp of recent Pause Event";
      }

      leaf last-resume-time {
        type uint64;
        description
          "Timestamp of recent Resume Event";
      }
    }  // grouping IEDGE-STATS-SRG-DATA

    grouping IEDGE-STATS-FADB-DATA {
      description "FADB statistics";
      leaf fadb-cleanup-sub-count {
        type uint32;
        description
          "Total num of times FADB cleanup by sublable";
      }

      leaf fadb-cleanup-ha-count {
        type uint32;
        description
          "Total num of times FADB delete records during HA
         that are invalid";
      }

      leaf fadb-cleanup-by-ifh-count {
        type uint32;
        description
          "Total num of times FADB delete records by ifh";
      }

      leaf fadb-cleanup-by-ifh-serv-count {
        type uint32;
        description
          "Total num of times FADB delete records by ifh
         and service";
      }

      leaf fadb-cleanup-by-ifh-ha-count {
        type uint32;
        description
          "Total num of times FADB delete records by ifh
         during HA that are invalid";
      }
    }  // grouping IEDGE-STATS-FADB-DATA

    grouping IEDGE-STATS-DISC-QUEUE-DATA {
      description "Disc queue statistics";
      leaf sess-disc-inflight-req {
        type uint32;
        description
          "Total num of times disc inflight req sent to
         subscriber fsm";
      }

      leaf sess-disc-inflight-res {
        type uint32;
        description
          "Total num of times disc inflight res received
         from subscriber fsm";
      }

      leaf disc-queue-count {
        type uint32;
        description
          "Num of session disconnects are in queue";
      }

      leaf disc-quota-remaining {
        type uint32;
        description
          "Session disconnect queue quota remaining";
      }

      leaf disc-quota {
        type uint32;
        description
          "Session Disconnect Quota";
      }

      leaf ppsm-fsm-is-congestion {
        type boolean;
        description "PPSM FSM is congestion";
      }

      leaf ppsm-trans-fsm-congestion-count {
        type uint32;
        description
          "PPSM trans FSM congestion count";
      }

      leaf txn-cnt-per-sec {
        type uint32;
        description
          "PPSM Transition per sec";
      }

      leaf creates-per-sec {
        type uint32;
        description
          "Session creation per sec";
      }

      leaf congest-per-sec {
        type uint32;
        description "Congestion per sec";
      }

      leaf discont-per-sec {
        type uint32;
        description "Disconnects per sec";
      }

      leaf avg-discont-per-sec {
        type uint32;
        description
          "Avg disconnects per sec";
      }

      leaf last-congestion-set-time {
        type uint64;
        description
          "Timestamp of recent congestion set";
      }

      leaf last-congestion-clr-time {
        type uint64;
        description
          "Timestamp of recent congestion clear";
      }
    }  // grouping IEDGE-STATS-DISC-QUEUE-DATA

    grouping IEDGE-DEBUG-TRACEPOINT-DATA {
      description
        "Iedge tracepoint debug stats";
      leaf trace-info {
        type uint32;
        description
          "Tracepoint information ";
      }

      leaf text {
        type string;
        description "Tracepoint text";
      }

      leaf traceindex-xr {
        type uint32;
        description "Tracepoint index";
      }
    }  // grouping IEDGE-DEBUG-TRACEPOINT-DATA

    grouping IEDGE-OPER-COA-DATA {
      description "IEDGE OPER COA DATA";
      leaf request-acked {
        type boolean;
        description "Coa Request Acked";
      }

      leaf request-time-epoch {
        type uint64;
        units "second";
        description
          "Request time in epoch seconds";
      }

      leaf reply-time-epoch {
        type uint64;
        units "second";
        description
          "Reply time in epoch seconds";
      }
    }  // grouping IEDGE-OPER-COA-DATA

    grouping IEDGE-OPER-SERVICE-DATA {
      description
        "Subscriber service information";
      leaf service-name {
        type string;
        description "ServiceName";
      }

      leaf service-params {
        type string;
        description "ServiceParams";
      }

      leaf service-type {
        type Iedge-oper-service;
        description "ServiceType";
      }

      leaf service-status {
        type Iedge-oper-service-status;
        description "ServiceStatus";
      }

      leaf service-id {
        type uint32;
        description "ServiceIdentifier";
      }

      leaf service-prepaid {
        type boolean;
        description "ServicePrepaid";
      }
    }  // grouping IEDGE-OPER-SERVICE-DATA

    grouping IEDGE-POLICY-DATA {
      description
        "Subscriber policy information";
      leaf policy-epoch {
        type string;
        description
          "Matching event, condition and executed actions";
      }
    }  // grouping IEDGE-POLICY-DATA

    grouping ACCT-LAST-STATS-DATA {
      description
        "Subscriber accounting last stats";
      leaf bytes-in {
        type uint32;
        units "byte";
        description
          "Bytes received from a port";
      }

      leaf input-giga-words {
        type uint32;
        description
          "Number of times that Acct-Input-Octets has
         wrapped";
      }

      leaf bytes-out {
        type uint32;
        units "byte";
        description "Bytes sent to a port";
      }

      leaf output-giga-words {
        type uint32;
        description
          "Number of times that Acct-Output-Octets has
         wrapped";
      }
    }  // grouping ACCT-LAST-STATS-DATA

    grouping IEDGE-OPER-ACCOUNTING-DATA {
      description
        "Session/Service accounting information";
      container last-stats {
        description
          "Stats sent in last accounting request";
        uses ACCT-LAST-STATS-DATA;
      }  // container last-stats

      leaf feature-id {
        type uint32;
        description
          "Feature id for FADB Record data";
      }

      leaf accounting-state-rc {
        type uint32;
        description
          "Accounting State Error Code for Accounting
         Session";
      }

      leaf accounting-stop-state {
        type uint32;
        description "Accounting Stop State";
      }

      leaf record-context-name {
        type string;
        description
          "Accounting record context name";
      }

      leaf method-list-name {
        type string;
        description
          "AAA method list name used to perform accounting";
      }

      leaf account-session-id {
        type string;
        description "Accounting session ID";
      }

      leaf accounting-start-time-epoch {
        type uint64;
        units "second";
        description
          "Accounting start time in epoch-seconds";
      }

      leaf is-interim-accounting-enabled {
        type boolean;
        description
          "True if interim accounting is enabled";
      }

      leaf interim-interval {
        type uint32;
        units "minute";
        description
          "Interim accounting interval (in minutes)";
      }

      leaf last-successful-interim-update-time-epoch {
        type uint64;
        units "second";
        description
          "Time of last successful interim update in
         epoch-seconds ";
      }

      leaf last-unsuccessful-interim-update-time-epoch {
        type uint64;
        units "second";
        description
          "Time of last unsuccessful interim update in
         epoch-seconds ";
      }

      leaf next-interim-update-attempt-time {
        type uint32;
        units "second";
        description
          "Time of next interim update attempt (in seconds)";
      }

      leaf last-interim-update-attempt-time-epoch {
        type uint64;
        units "second";
        description
          "Time of last interim update attempt in
         epoch-seconds";
      }

      leaf sent-interim-updates {
        type uint32;
        description
          "Number of interim updates sent";
      }

      leaf accepted-interim-updates {
        type uint32;
        description
          "Number of interim updates accepted";
      }

      leaf rejected-interim-updates {
        type uint32;
        description
          "Number of interim updates rejected";
      }

      leaf sent-interim-update-failures {
        type uint32;
        description
          "Number of interim update send failures";
      }
    }  // grouping IEDGE-OPER-ACCOUNTING-DATA

    grouping IEDGE-ACCNT-DATA {
      description "Accounting information";
      list accounting-session {
        description "Accounting information";
        uses IEDGE-OPER-ACCOUNTING-DATA;
      }  // list accounting-session
    }  // grouping IEDGE-ACCNT-DATA

    grouping SUBSCRIBER-SESSION-DATA {
      description
        "Subscriber session information";
      container accounting {
        description "Accounting information";
        uses IEDGE-ACCNT-DATA;
      }  // container accounting

      leaf session-type {
        type Iedge-oper-session;
        description
          "Subscriber session type";
      }

      leaf pppoe-sub-type {
        type Iedge-ppp-sub;
        description "PPPoE sub type";
      }

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

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

      leaf circuit-id {
        type string;
        description "Circuit ID";
      }

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

      leaf lns-address {
        type Ipv4-address;
        description "PPPoE LNS address";
      }

      leaf lac-address {
        type Ipv4-address;
        description "PPPoE LAC address";
      }

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

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

      leaf session-ip-address {
        type Ipv4-address;
        description "Session ip address";
      }

      leaf session-ipv6-address {
        type string;
        description "Session IPv6 address";
      }

      leaf session-ipv6-prefix {
        type string;
        description "Session IPv6 prefix";
      }

      leaf delegated-ipv6-prefix {
        type string;
        description
          "Session delegated IPv6 prefix";
      }

      leaf ipv6-interface-id {
        type Hex-binary;
        description "IPv6 Interface ID";
      }

      leaf mac-address {
        type Mac-address;
        description "MAC address";
      }

      leaf account-session-id {
        type string;
        description "Accounting session ID";
      }

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

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

      leaf clientname {
        type string;
        description "Client Username";
      }

      leaf formattedname {
        type string;
        description "Formatted Username";
      }

      leaf is-session-authentic {
        type boolean;
        description
          "If true, session is authentic";
      }

      leaf is-session-author {
        type boolean;
        description
          "If true, session is authorized";
      }

      leaf session-state {
        type Iedge-oper-session-state;
        description "Session state";
      }

      leaf session-creation-time-epoch {
        type uint64;
        units "second";
        description
          "Session creation time in epoch seconds";
      }

      leaf idle-state-change-time {
        type string;
        description
          "Time when idle state change occurred in DDD MMM
         DD HH:MM:SS YYYY format eg: Tue Apr 11 21:30:47
         2011";
      }

      leaf total-session-idle-time {
        type uint32;
        units "second";
        description
          "Total session idle time (in seconds)";
      }

      leaf access-interface-name {
        type xr:Interface-name;
        description
          "Access interface name associated with the
         session";
      }

      leaf accounting-stop-fail-rc {
        type uint32;
        description
          "Accounting Stop Error Code for Accounting
         Session";
      }

      list sub-policy-data {
        description
          "Subscriber control policy applied to this
         session";
        uses IEDGE-POLICY-DATA;
      }  // list sub-policy-data

      list session-service-info {
        description
          "List of subscriber services associated to this
         session";
        uses IEDGE-OPER-SERVICE-DATA;
      }  // list session-service-info

      list session-change-of-authorization {
        description
          "Subscriber change of authorization information";
        uses IEDGE-OPER-COA-DATA;
      }  // list session-change-of-authorization
    }  // grouping SUBSCRIBER-SESSION-DATA

    grouping IEDGE-DISCONNECT-DATA {
      description "IEDGE DISCONNECT DATA";
      container session-data {
        description "Session data";
        uses SUBSCRIBER-SESSION-DATA;
      }  // container session-data

      leaf disc-reason-xr {
        type string;
        description "Disconnect reason";
      }

      leaf session-count {
        type uint32;
        description
          "Number of sessions that disconnected this way";
      }

      leaf latest-activity {
        type uint32;
        description "Latest activity";
      }

      leaf if-name {
        type string;
        description "Interface name";
      }
    }  // grouping IEDGE-DISCONNECT-DATA

    grouping IEDGE-STATS-DISCONNECT-DATA {
      description "Disconnect data";
      list history-data {
        description
          "List of disconnect history items";
        uses IEDGE-DISCONNECT-DATA;
      }  // list history-data
    }  // grouping IEDGE-STATS-DISCONNECT-DATA

    grouping IEDGE-STATS-SUMMARY-DATA {
      description "Summary statistics";
      leaf no-subscriber-control-policy-on-interface {
        type uint64;
        description
          "Subscriber control policy not applied on
         interface";
      }

      leaf no-class-match-in-start-request {
        type uint64;
        description
          "No control policy class match during subscriber
         start";
      }

      leaf nas-port-attribute-format-warnings {
        type uint64;
        description
          "NAS port attribute format warnings";
      }

      leaf nas-port-id-attribute-format-warnings {
        type uint64;
        description
          "NAS port ID attribute format warnings";
      }

      leaf destination-station-id-attribute-format-warnings {
        type uint64;
        description
          "Destination station ID attribute format warnings";
      }

      leaf calling-station-id-attribute-format-warnings {
        type uint64;
        description
          "Calling station ID attribute format warnings";
      }

      leaf username-attribute-format-warnings {
        type uint64;
        description
          "Username attribute format warnings";
      }

      leaf install-user-profiles {
        type uint64;
        description
          "User profiles installed";
      }

      leaf user-profile-install-errors {
        type uint64;
        description
          "User profile install errors";
      }

      leaf user-profile-removals {
        type uint64;
        description "User profile removals";
      }

      leaf user-profile-errors {
        type uint64;
        description "User profile errors";
      }

      leaf sess-disc-quota-exhausts {
        type uint64;
        description
          "Session Disconnect Quota Exhausts";
      }

      leaf sess-disc-no-quota {
        type uint64;
        description
          "Session Disconnect Request Queued, no quota";
      }

      leaf sess-disc-quota-avail {
        type uint64;
        description
          "Session Disconnect Request Accepted, quota
         available";
      }

      leaf sess-disc-recon-ip {
        type uint64;
        description
          "Session Disconnect Requests not Dequeued,
         reconciliation in progress";
      }

      leaf sess-disc-none-started {
        type uint64;
        description
          "Session Disconnect Requests not Dequeued, no
         quota";
      }

      leaf sess-disc-quota {
        type uint32;
        description
          "Session Disconnect Quota";
      }

      leaf sess-disc-quota-remaining {
        type uint32;
        description
          "Session Disconnect Quota Remaining";
      }

      leaf sess-disc-q-count {
        type uint32;
        description
          "Session Disconnect Requests Queued";
      }
    }  // grouping IEDGE-STATS-SUMMARY-DATA

    grouping IEDGE-STATS-CH-REQ-STATS {
      description
        "Change of authorization request statistics";
      leaf received-requests {
        type uint64;
        description "Received requests";
      }

      leaf acknowledged-requests {
        type uint64;
        description "Acknowledged requests";
      }

      leaf non-acknowledged-requests {
        type uint64;
        description
          "Non acknowledged requests";
      }
    }  // grouping IEDGE-STATS-CH-REQ-STATS

    grouping IEDGE-STATS-CH-DATA {
      description
        "Change of authorization statistics";
      container account-logon {
        description
          "Account logon request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container account-logon

      container account-logoff {
        description
          "Account logoff request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container account-logoff

      container account-update {
        description
          "Account update request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container account-update

      container session-disconnect {
        description
          "Session disconnect request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container session-disconnect

      container single-service-logon {
        description
          "Service logon request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container single-service-logon

      container single-service-logoff {
        description
          "Single Service logoff request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container single-service-logoff

      container single-service-modify {
        description
          "Single Service Modify request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container single-service-modify

      container service-multi {
        description
          "MA-CoA Service request statistics";
        uses IEDGE-STATS-CH-REQ-STATS;
      }  // container service-multi

      leaf unknown-account-cmd-resps {
        type uint64;
        description
          "Responses to unknown account command";
      }

      leaf unknown-service-cmd-resps {
        type uint64;
        description
          "Responses to unknown service command";
      }

      leaf unknown-cmd-resps {
        type uint64;
        description
          "Responses to unknown command";
      }

      leaf attr-list-retrieve-failure-resps {
        type uint64;
        description
          "Responses to attribute list failure errors";
      }

      leaf resp-send-failure {
        type uint64;
        description "Response send failures";
      }

      leaf internal-err-resps {
        type uint64;
        description
          "Responses to internal error";
      }

      leaf service-profile-push-failure-resps {
        type uint64;
        description
          "Responses to service profile push failures";
      }

      leaf no-cmd-resps {
        type uint64;
        description
          "Responses empty (no command) COA request";
      }

      leaf no-session-found-resps {
        type uint64;
        description
          "Responses to COA with unknown session identifier";
      }

      leaf no-session-peer-resps {
        type uint64;
        description
          "Responses to session peer not found error";
      }
    }  // grouping IEDGE-STATS-CH-DATA

    grouping IEDGE-STATS-COORD-ALL-DATA {
      description
        "IEDGE STATS COORD ALL DATA";
      container accounting-statistics {
        description
          "List of stats for accounting";
        uses IEDGE-STATS-COORD-ACCT-DATA;
      }  // container accounting-statistics

      container authentication-statistics {
        description
          "List of stats for authentication";
        uses IEDGE-STATS-COORD-AUTH-DATA;
      }  // container authentication-statistics

      container authorization-statistics {
        description
          "List of stats for authorization";
        uses IEDGE-STATS-COORD-AUTH-DATA;
      }  // container authorization-statistics

      container change-of-authorization-statistics {
        description "List of stats for COA";
        uses IEDGE-STATS-CH-DATA;
      }  // container change-of-authorization-statistics

      container mobility-statistics {
        description
          "List of stats for Mobility";
        uses IEDGE-STATS-MOB-DATA;
      }  // container mobility-statistics
    }  // grouping IEDGE-STATS-COORD-ALL-DATA

    grouping IEDGE-COORD-STOP-STORAGE-ACCT-STATS-DATA {
      description
        "AAA acct stop record acct stats bag info";
      leaf rec-sess-stop-req {
        type uint64;
        description
          "Acct record sess stop req stats";
      }

      leaf rec-sess-stop-err {
        type uint64;
        description
          "Acct record sess stop req error stats";
      }

      leaf rec-sess-stop-snt {
        type uint64;
        description
          "Acct record sess stop req sent stats";
      }

      leaf rec-sess-stop-succ {
        type uint64;
        description
          "Acct record sess stop response success";
      }

      leaf rec-sess-stop-fail {
        type uint64;
        description
          "Acct record sess stop response fail";
      }

      leaf rec-serv-stop-req {
        type uint64;
        description
          "Acct record serv stop req stats";
      }

      leaf rec-serv-stop-err {
        type uint64;
        description
          "Acct record serv stop req error stats";
      }

      leaf rec-serv-stop-snt {
        type uint64;
        description
          "Acct record serv stop req sent stats";
      }

      leaf rec-serv-stop-succ {
        type uint64;
        description
          "Acct record serv stop response success";
      }

      leaf rec-serv-stop-fail {
        type uint64;
        description
          "Acct record serv stop response fail";
      }

      leaf rec-srg-stop-retry-req {
        type uint64;
        description
          "Acct record srg stop retry req";
      }

      leaf rec-srg-stop-retry-req-err {
        type uint64;
        description
          "Acct record srg stop retry req error";
      }

      leaf rec-srg-stop-retry-req-snt {
        type uint64;
        description
          "Acct record srg stop retry req sent";
      }

      leaf rec-srg-stop-start-req {
        type uint64;
        description
          "Acct record srg stop start req";
      }

      leaf rec-srg-stop-start-req-err {
        type uint64;
        description
          "Acct record srg stop start req error";
      }

      leaf rec-srg-stop-start-req-snt {
        type uint64;
        description
          "Acct record srg stop start req sent";
      }
    }  // grouping IEDGE-COORD-STOP-STORAGE-ACCT-STATS-DATA

    grouping IEDGE-COORD-STOP-STORAGE-INT-DATA {
      description
        "AAA accounting stop storage internal bag info";
      leaf get-free-index {
        type uint64;
        description
          "Num of Free Index Requests Received";
      }

      leaf get-free-index-err {
        type uint64;
        description
          "Num of Free Index Requests Errored";
      }

      leaf offset-q-init {
        type uint64;
        description
          "Num of times OffsetQ initialized";
      }

      leaf stop-rec-data-init {
        type uint64;
        description
          "Num of times Stop Rec Data initialized";
      }

      leaf alloc-free-list-fail {
        type uint64;
        description
          "Alloc free list creation failed";
      }

      leaf alloc-free-list-succ {
        type uint64;
        description
          "Alloc free list creation succ";
      }

      leaf rec-chkpt-init-fail {
        type uint64;
        description "Rec chkpt init failed";
      }

      leaf rec-chkpt-init-succ {
        type uint64;
        description "Rec chkpt init Success";
      }

      leaf rec-chkpt-restore-succ {
        type uint64;
        description "Rec chkpt restore succ";
      }

      leaf rec-chkpt-restore-fail {
        type uint64;
        description "Rec chkpt restore Fail";
      }

      leaf rec-wavl-init-succ {
        type uint64;
        description "Rec wavl init succ";
      }

      leaf rec-wavl-init-fail {
        type uint64;
        description "Rec wavl init fail";
      }

      leaf mlist-retrive-cb {
        type uint64;
        description
          "Num of Mlist Retrived Callback called";
      }

      leaf mlist-retrive-enq {
        type uint64;
        description
          "Num of Mlist Retrived Enqueue called";
      }

      leaf mlist-retrive-notif {
        type uint64;
        description
          "Num of Mlist Retrived Notified";
      }

      leaf sub-ctx-upd-restart {
        type uint64;
        description
          "Num of Subs Context Updated on restart";
      }

      leaf sub-ctx-upd-restart-fail {
        type uint64;
        description
          "Num of Subs Context Updated on restart failed";
      }

      leaf free-index-over {
        type uint64;
        description
          "Num of times Free list got over";
      }

      leaf free-index-over-err {
        type uint64;
        description
          "Num of times Free list got over errored";
      }

      leaf mlist-used-offset-enq {
        type uint64;
        description
          "Mlist Used OffsetQ Enqueue";
      }

      leaf mem-alloc-fail {
        type uint64;
        description "Memory Alloc Failed";
      }

      leaf alloc-free-list {
        type uint64;
        description "Alloc Free List ";
      }

      leaf mlist-enq {
        type uint64;
        description "Mlist Enqueue";
      }

      leaf mark-mlist-down {
        type uint64;
        description "Mlist Mark Down";
      }

      leaf used-offset-enq {
        type uint64;
        description "Used OffsetQ Enqueue";
      }

      leaf free-offset-enq {
        type uint64;
        description "Free OffsetQ Enqueue";
      }

      leaf free-mlist {
        type uint64;
        description "Free Method List";
      }

      leaf free-used-list {
        type uint64;
        description "Free Used List";
      }

      leaf free-free-list {
        type uint64;
        description "Free FreeList";
      }

      leaf chkpt-delete {
        type uint64;
        description "Delete Checkpoint Data";
      }

      leaf chkpt-delete-err {
        type uint64;
        description
          "Delete Checkpoint Data Error";
      }

      leaf del-mlist-used-offset {
        type uint64;
        description
          "Delete MList used offset pointer";
      }

      leaf chkpt-save {
        type uint64;
        description "Save Checkpoint Data";
      }

      leaf chkpt-save-err {
        type uint64;
        description
          "Save Checkpoint Data Error";
      }

      leaf del-used-offset {
        type uint64;
        description "Delete Used Offset";
      }

      leaf rec-to-thread {
        type uint64;
        description
          "Enqueue and Send signal";
      }

      leaf rec-to-thread-sig {
        type uint64;
        description "Signal to new thread";
      }

      leaf thread-handler {
        type uint64;
        description
          "No of times thread handler called";
      }

      leaf thread-handler-wait {
        type uint64;
        description
          "No of times thread handler wait called";
      }

      leaf del-used-offset-expiry {
        type uint64;
        description
          "Delete used offset if aged out";
      }

      leaf start-short-timer {
        type uint64;
        description "Start Short Timer";
      }

      leaf start-retry-timer {
        type uint64;
        description "Start Retry Timer";
      }

      leaf retry-used-offset {
        type uint64;
        description
          "Retry Used Offset Count";
      }

      leaf rec-msg-sent {
        type uint64;
        description "Record msg sent";
      }

      leaf rec-msg-retry {
        type uint64;
        description "Record msg retry";
      }

      leaf rec-msg-rtrv-mlist {
        type uint64;
        description
          "Record msg retrieve method list";
      }

      leaf rec-msg-srg-retry-stop {
        type uint64;
        description
          "Record msg srg retry stop";
      }

      leaf rec-msg-default {
        type uint64;
        description "Record msg default";
      }

      leaf rec-open-file-succ {
        type uint32;
        description
          "Record open file success";
      }

      leaf rec-open-file-fail {
        type uint32;
        description "Record open file fail";
      }

      leaf rec-close-file {
        type uint32;
        description "Record close file";
      }

      leaf rec-unlink-file {
        type uint32;
        description "Record unlink file";
      }

      leaf rec-wrt-file-succ {
        type uint64;
        description "Record write file succ";
      }

      leaf rec-wrt-file-fail {
        type uint64;
        description "Record write file fail";
      }

      leaf rec-read-file-succ {
        type uint64;
        description "Record read file succ ";
      }

      leaf rec-read-file-fail {
        type uint64;
        description "Record read file fail";
      }

      leaf rec-eor-not-found {
        type uint64;
        description
          "Acct record EOR not found";
      }

      leaf rec-crt-tm-mismatch {
        type uint64;
        description
          "Acct record creation time mismatch found";
      }

      leaf rec-aaa-req-dropped {
        type uint64;
        description
          "Acct record aaa request dropped";
      }

      leaf rec-retry-file-open {
        type uint64;
        description
          "Acct record retry file open";
      }

      leaf rec-rpl-to-rec-fail {
        type uint64;
        description
          "Acct record rpl to record Failed";
      }

      leaf rec-rpl-to-rec-succ {
        type uint64;
        description
          "Acct record rpl to record Success";
      }

      leaf rec-rpl-updt-fail {
        type uint64;
        description
          "Acct record rpl update failed";
      }

      leaf rec-rpl-updt-succ {
        type uint64;
        description
          "Acct record rpl update success";
      }

      leaf rec-rpl-standby-up-fail {
        type uint64;
        description
          "Acct record rpl stand by up failed";
      }

      leaf rec-rpl-standby-up-succ {
        type uint64;
        description
          "Acct record rpl stand by up Success";
      }

      leaf rec-rpl-snd-msg-fail {
        type uint64;
        description
          "Acct record rpl send msg failed";
      }

      leaf rec-rpl-snd-msg-succ {
        type uint64;
        description
          "Acct record rpl send msg success";
      }

      leaf rec-rpl-init-fail {
        type uint8;
        description
          "Acct record rpl init failed";
      }

      leaf rec-rpl-init-succ {
        type uint8;
        description
          "Acct record rpl init success";
      }

      leaf rec-rpl-getdh-fail {
        type uint8;
        description
          "Acct record rpl get data handle failed";
      }

      leaf rec-rpl-getdh-succ {
        type uint8;
        description
          "Acct record rpl get data handle success";
      }

      leaf rec-rpl-standby-up-offset-cnt {
        type uint64;
        description
          "Acct record rpl standby up offset count";
      }

      leaf rec-sync-standby-offset-cnt {
        type uint64;
        description
          "Acct record sync standby offset count";
      }

      leaf rec-rpl-batch-timer-expire-cnt {
        type uint64;
        description
          "Acct record rpl batch timer expire count";
      }

      leaf rec-rpl-batch-timer-start-cnt {
        type uint64;
        description
          "Acct record rpl batch timer start count";
      }

      leaf rec-rpl-updt-done-fail {
        type uint64;
        description
          "Acct record rpl updt done cb fail cnt";
      }

      leaf rec-msg-batch-timer {
        type uint64;
        description
          "Record msg batch timer count";
      }

      leaf rec-msg-sync-standby {
        type uint64;
        description
          "Record msg sync standby";
      }

      leaf retry-skipped {
        type uint64;
        description
          "Retry Used offset skipped";
      }
    }  // grouping IEDGE-COORD-STOP-STORAGE-INT-DATA

    grouping IEDGE-COORD-STOP-STORAGE-SUM-DATA {
      description
        "AAA accounting stop storage sum bag info";
      leaf method-list-name {
        type string;
        description
          "AAA method list name used to perform accounting";
      }

      leaf method-list-status {
        type boolean;
        description "AAA method list status";
      }

      leaf usedlist-count {
        type uint32;
        description
          "Num of acct stop response yet to receive from
         AAA base";
      }

      leaf num-of-record {
        type uint32;
        description
          "Max number of records conf on the box";
      }

      leaf max-time {
        type uint32;
        units "second";
        description
          "max life time of record in harddisk (in seconds)";
      }

      leaf msg-count {
        type uint32;
        description
          "Num of msg yet to write into file";
      }

      leaf retry-timer-start {
        type uint32;
        description "Retry timer start";
      }

      leaf retry-timer-timeout {
        type uint32;
        units "second";
        description
          "Retry timer timeout (in seconds)";
      }
    }  // grouping IEDGE-COORD-STOP-STORAGE-SUM-DATA

    grouping IEDGE-COORD-STOP-STORAGE-DETAIL-DATA {
      description
        "AAA accounting stop storage detail bag info";
      leaf method-list-name {
        type string;
        description
          "AAA method list name used to perform accounting";
      }

      leaf method-list-status {
        type boolean;
        description "AAA method list status";
      }

      leaf account-session-id {
        type string;
        description "Accounting session ID";
      }

      leaf session-acct-type {
        type uint8;
        description
          "Accounting session ID type";
      }

      leaf file-offset-index {
        type uint32;
        description "File offset index";
      }

      leaf session-label {
        type uint32;
        description "Unique subscriber ID";
      }

      leaf offset-index-timeout {
        type uint32;
        units "second";
        description
          "Offset index timeout (in seconds)";
      }

      leaf elapsed-time {
        type uint32;
        units "second";
        description
          "Offset entry elapsed time (in seconds)";
      }

      leaf rad-response-pending-state {
        type boolean;
        description
          "Radius response pending state";
      }
    }  // grouping IEDGE-COORD-STOP-STORAGE-DETAIL-DATA

    grouping IEDGE-STATS-MOB-DATA {
      description "Mobility statistics";
      leaf send-request-successes {
        type uint64;
        description "Request send success";
      }

      leaf send-request-failures {
        type uint64;
        description "Request send failures";
      }

      leaf receive-response-successes {
        type uint64;
        description
          "Response receive success";
      }

      leaf receive-response-failures {
        type uint64;
        description
          "Response receive failures";
      }
    }  // grouping IEDGE-STATS-MOB-DATA

    grouping IEDGE-STATS-COORD-AUTH-DATA {
      description
        "Authorization & authentication statistics";
      leaf sent-requests {
        type uint64;
        description
          "Requests sent to radius server";
      }

      leaf accepted-requests {
        type uint64;
        description
          "Request accepted by Radius server";
      }

      leaf successful-requests {
        type uint64;
        description
          "Requests which are successful";
      }

      leaf rejected-requests {
        type uint64;
        description
          "Requests rejected by radius server";
      }

      leaf unreachable-requests {
        type uint64;
        description
          "Radius server not available";
      }

      leaf errored-requests {
        type uint64;
        description "Unexpected errors";
      }

      leaf terminated-requests {
        type uint64;
        description
          "Requests terminated by disconnect";
      }
    }  // grouping IEDGE-STATS-COORD-AUTH-DATA

    grouping IEDGE-INTERIM-INFLIGHT-COORD-DATA {
      description
        "Interim inflight information";
      leaf quota-exhausts {
        type uint32;
        description "Quota exhausts";
      }

      leaf denied-requests {
        type uint32;
        description "Denied requests";
      }

      leaf accepted-requests {
        type uint32;
        description "Accepted requests";
      }

      leaf total-quota-of-requests {
        type uint32;
        description
          "Total quota of requests";
      }

      leaf remaining-quota-of-requests {
        type uint32;
        description
          "Remaining quota of requests";
      }

      leaf low-water-mark-quota-of-requests {
        type uint32;
        description
          "Low water mark quota of requests";
      }
    }  // grouping IEDGE-INTERIM-INFLIGHT-COORD-DATA

    grouping IEDGE-STATS-COORD-ACCT-REQ-STATS {
      description
        "AAA accounting request-response statistics";
      leaf received-requests {
        type uint64;
        description "Received requests";
      }

      leaf errored-requests {
        type uint64;
        description "Errored requests";
      }

      leaf aaa-errored-requests {
        type uint64;
        description "AAA errored requests";
      }

      leaf aaa-sent-requests {
        type uint64;
        description "AAA requests sent";
      }

      leaf aaa-succeeded-responses {
        type uint64;
        description
          "AAA succeeded responses";
      }

      leaf aaa-failed-responses {
        type uint64;
        description "AAA failed responses";
      }
    }  // grouping IEDGE-STATS-COORD-ACCT-REQ-STATS

    grouping IEDGE-STATS-COORD-ACCT-DATA {
      description
        "AAA accounting statistics";
      container start {
        description "Start statistics";
        uses IEDGE-STATS-COORD-ACCT-REQ-STATS;
      }  // container start

      container stop {
        description "Stop statistics";
        uses IEDGE-STATS-COORD-ACCT-REQ-STATS;
      }  // container stop

      container interim {
        description "Interim statistics";
        uses IEDGE-STATS-COORD-ACCT-REQ-STATS;
      }  // container interim

      container pass-through {
        description
          "Pass-through statistics";
        uses IEDGE-STATS-COORD-ACCT-REQ-STATS;
      }  // container pass-through

      container update {
        description "Update statistics";
        uses IEDGE-STATS-COORD-ACCT-REQ-STATS;
      }  // container update

      container interim-inflight {
        description
          "Interim inflight details";
        uses IEDGE-INTERIM-INFLIGHT-COORD-DATA;
      }  // container interim-inflight

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

      leaf started-sessions {
        type uint64;
        description "Started sessions";
      }

      leaf stopped-sessions {
        type uint64;
        description "Stopped sessions";
      }

      leaf policy-plane-errored-requests {
        type uint64;
        description
          "Policy plane errored requests";
      }

      leaf policy-plane-unknown-requests {
        type uint64;
        description
          "Policy plane unknown requests";
      }
    }  // grouping IEDGE-STATS-COORD-ACCT-DATA
  }  // submodule Cisco-IOS-XR-iedge4710-oper-sub2