submodule Cisco-IOS-XR-infra-serg-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-infra-serg-oper {
        prefix
          Cisco-IOS-XR-infra-serg-oper;
    }

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

    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 "1.0.1";

    typedef Serg-show-so-reason {
      type enumeration {
        enum "internal" {
          value 0;
          description
            "SwitchOver for Internal Reason";
        }
        enum "admin" {
          value 1;
          description "SwitchOver for Admin";
        }
        enum "peer-up" {
          value 2;
          description
            "SwitchOver for Peer UP";
        }
        enum "peer-down" {
          value 3;
          description
            "SwitchOver for Peer Down";
        }
        enum "object-tracking-status-change" {
          value 4;
          description
            "SwitchOver for Object Tracking status change";
        }
        enum "serg-show-so-reason-max" {
          value 5;
          description
            "Unknown Switchover Reason";
        }
      }
      description
        "Session Redundancy Switchover Reason";
    }

    typedef Serg-peer-status {
      type enumeration {
        enum "not-configured" {
          value 0;
          description "Peer not configured";
        }
        enum "initialize" {
          value 1;
          description "Peer initialization";
        }
        enum "retry" {
          value 2;
          description "Peer retry pending";
        }
        enum "connect" {
          value 3;
          description
            "Connection in Progress";
        }
        enum "listen" {
          value 4;
          description
            "Listening in Progress";
        }
        enum "registration" {
          value 5;
          description
            "Awaiting Registration from Peer";
        }
        enum "cleanup" {
          value 6;
          description
            "Peer cleanup in progress";
        }
        enum "connected" {
          value 7;
          description "Peer Connected";
        }
        enum "established" {
          value 8;
          description "Peer Established";
        }
      }
      description "SERG Peer Status";
    }

    typedef Serg-show-session-error {
      type enumeration {
        enum "none" {
          value 0;
          description "Invalid Error";
        }
        enum "hard" {
          value 1;
          description "Hard Error";
        }
        enum "soft" {
          value 2;
          description "Soft Error";
        }
      }
      description
        "SERG Session Error Operation";
    }

    typedef Serg-show-session-operation {
      type enumeration {
        enum "none" {
          value 0;
          description "No Operation";
        }
        enum "update" {
          value 1;
          description
            "SERG Session Update Operation";
        }
        enum "delete" {
          value 2;
          description
            "SERG Session Delete Operation";
        }
        enum "in-sync" {
          value 3;
          description "SERG Session In Sync";
        }
      }
      description "SERG Session Operation";
    }

    typedef Serg-show-comp {
      type enumeration {
        enum "serga" {
          value 0;
          description "SERG Agent";
        }
        enum "ipv6nd" {
          value 1;
          description "IPv6ND";
        }
        enum "dhcpv6" {
          value 2;
          description "DHCPv6";
        }
        enum "daps" {
          value 3;
          description "DAPS";
        }
      }
      description "SERG Components";
    }

    typedef Serg-show-slave-mode {
      type enumeration {
        enum "none" {
          value 0;
          description "Not Configured";
        }
        enum "warm" {
          value 1;
          description "Warm Modem";
        }
        enum "hot" {
          value 2;
          description "Hot Mode";
        }
      }
      description "SERG Slave Mode";
    }

    typedef Serg-show-role {
      type enumeration {
        enum "none" {
          value 0;
          description "Not Configured";
        }
        enum "master" {
          value 1;
          description "Master Role";
        }
        enum "slave" {
          value 2;
          description "Slave Role";
        }
        enum "active" {
          value 3;
          description "Active Role";
        }
      }
      description "SERG Role";
    }

    typedef Serg-show-im-role {
      type enumeration {
        enum "none" {
          value 0;
          description "Not Determined";
        }
        enum "master" {
          value 1;
          description "Master Role";
        }
        enum "slave" {
          value 2;
          description "Slave Role";
        }
        enum "active" {
          value 3;
          description "Active Role";
        }
      }
      description
        "SERG Interface Management Role";
    }

    grouping SERG-AGT-SHOW-GROUP-LIST-ENTRY {
      description
        "Session Redundancy Agent Group Summary
       Information";
      leaf group-id-xr {
        type uint32;
        description "Group ID";
      }

      leaf role {
        type Serg-show-im-role;
        description "SERG Role";
      }

      leaf disabled {
        type boolean;
        description "Disabled by Config";
      }

      leaf peer-ipv4-address {
        type inet:ipv4-address;
        description "Peer IPv4 Address";
      }

      leaf peer-ipv6-address {
        type inet:ipv6-address;
        description "Peer IPv6 Address";
      }

      leaf peer-status {
        type Serg-peer-status;
        description "Peer Status";
      }

      leaf preferred-role {
        type Serg-show-role;
        description "Preferred Role";
      }

      leaf slave-mode {
        type Serg-show-slave-mode;
        description "Slave Mode";
      }

      leaf object-tracking-status {
        type boolean;
        description
          "Object Tracking Status (Enabled/Disabled)";
      }

      leaf interface-count {
        type uint32;
        description "Interface Count";
      }

      leaf session-count {
        type uint32;
        description "Session Count";
      }

      leaf pending-add-session-count {
        type uint32;
        description
          "Pending Session Count for Synchornization";
      }
    }  // grouping SERG-AGT-SHOW-GROUP-LIST-ENTRY

    grouping SERG-SHOW-TXLSTAT {
      description "serg txlstat";
      leaf tx-list-encode-marker-ok {
        type uint32;
        description "TxListEncodeMarkerOk";
      }

      leaf tx-list-encode-marker-partial-write {
        type uint32;
        description
          "TxListEncodeMarkerPartialWrite";
      }

      leaf tx-list-clean-marker {
        type uint32;
        description "TxListCleanMarker";
      }

      leaf tx-list-encode-command-ok {
        type uint32;
        description "TxListEncodeCommandOk";
      }

      leaf tx-list-encode-command-partial-write {
        type uint32;
        description
          "TxListEncodeCommandPartialWrite";
      }

      leaf tx-list-clean-command {
        type uint32;
        description "TxListCleanCommand";
      }

      leaf tx-list-encode-negotiation-ok {
        type uint32;
        description
          "TxListEncodeNegotiationOk";
      }

      leaf tx-list-encode-negotiation-partial-write {
        type uint32;
        description
          "TxListEncodeNegotiationPartialWrite";
      }

      leaf tx-list-clean-negotiation {
        type uint32;
        description "TxListCleanNegotiation";
      }
    }  // grouping SERG-SHOW-TXLSTAT

    grouping SERG-SHOW-IDB-STATUS-STAT {
      description "serg idb status stat";
      leaf pend-caps-rem-cnt {
        type uint32;
        description
          "No. of interfaces pending caps remove";
      }

      leaf pend-reg-disable-cnt {
        type uint32;
        description
          "No. of interfaces pending red disable";
      }

      leaf pend-other-batch-oper-cnt {
        type uint32;
        description
          "No. of interfaces pending for other (except
         unreg/caps rem) batch oper";
      }

      leaf non-stale-cnt {
        type uint32;
        description
          "No. of non stale interfaces";
      }

      leaf grp-bound-cnt {
        type uint32;
        description
          "No. of interface bound to a group";
      }
    }  // grouping SERG-SHOW-IDB-STATUS-STAT

    grouping SERG-SHOW-TXSEND-TCP-STATISTICS {
      description
        "TxSend Global Statistics Information";
      leaf messages-sent {
        type uint32;
        description "Message Sent Count";
      }

      leaf bytes-sent {
        type uint32;
        units "byte";
        description "Bytes Sent Count";
      }

      leaf messages-received {
        type uint32;
        description "Message Received Count";
      }

      leaf bytes-received {
        type uint32;
        units "byte";
        description "Bytes Received Count";
      }

      leaf connect-count {
        type uint32;
        description "Socket Connect Count";
      }

      leaf blocked-connect-count {
        type uint32;
        description
          "Blocked Socket Connect Count";
      }

      leaf connect-retry-count {
        type uint32;
        description
          "Socket Connect Retry Count";
      }

      leaf remote-node-down-count {
        type uint32;
        description
          "Remote Peer DisConnect Count";
      }

      leaf accept-count {
        type uint32;
        description "Socket Accept Count";
      }

      leaf maximum-sent-message-size {
        type uint32;
        description
          "Maximum Size of Sent Message";
      }

      leaf maximum-received-message-size {
        type uint32;
        description
          "Maximum Size of Received Message";
      }

      leaf peer-pause-count {
        type uint32;
        description "Peer Pause Count";
      }

      leaf buffer-full-occurence-count {
        type uint32;
        description
          "Buffer Full on Write Occurence Count";
      }

      leaf mem-move-message-count {
        type uint32;
        description
          "Partial Message Memory Move Occurence Count";
      }

      leaf mem-move-bytes-count {
        type uint32;
        description
          "Partial Message Memory Move Byte Count";
      }

      leaf socket-read-count {
        type uint32;
        description "Socket Read Count";
      }

      leaf socket-write-count {
        type uint32;
        description "Socket Write Count";
      }

      leaf active-socket-count {
        type uint16;
        description "Active Socket Count";
      }

      leaf maximum-requested-buffer-size {
        type uint32;
        description
          "Maximum Size of Requested Buffer";
      }

      leaf buffer-freed-count {
        type uint16;
        description "Buffer Free Count";
      }

      leaf buffer-cache-hit {
        type uint16;
        description "Buffer Cache Hit Count";
      }

      leaf buffer-cache-miss {
        type uint16;
        description
          "Buffer Cache Miss Count";
      }
    }  // grouping SERG-SHOW-TXSEND-TCP-STATISTICS

    grouping SERG-SHOW-OPQ-MEM-STATS {
      description "serg show opq mem stats";
      leaf component {
        type Serg-show-comp;
        description "Component";
      }

      leaf session-count {
        type uint32;
        description
          "Session count for each component";
      }

      leaf opaque-size {
        type uint32;
        description
          "Current Opaque Memory Size for each component";
      }

      leaf opaque-high-size {
        type uint32;
        description
          "High Watermark of Opaque Data Size for each
         component";
      }

      leaf opaque-data-size {
        type uint32;
        description
          "Current Opaque Data Size for each component";
      }
    }  // grouping SERG-SHOW-OPQ-MEM-STATS

    grouping SERG-SHOW-AGT-CLIENT-STATUS {
      description
        "serg show agt client status";
      leaf component {
        type Serg-show-comp;
        description "Component";
      }

      leaf client-connection-status {
        type boolean;
        description "ClientConnectionStatus";
      }

      leaf client-initialization-synchronization-pending {
        type boolean;
        description
          "ClientInitializationSynchronizationPending";
      }

      leaf client-synchronization-end-of-download-pending {
        type boolean;
        description
          "ClientSynchronizationEndOfDownloadPending";
      }

      leaf up-time-stamp {
        type string;
        description "UpTimeStamp";
      }

      leaf down-time-stamp {
        type string;
        description "DownTimeStamp";
      }

      leaf clean-up-timer-remaining {
        type uint32;
        units "second";
        description
          "Value in Seconds to trigger the client cleanup";
      }
    }  // grouping SERG-SHOW-AGT-CLIENT-STATUS

    grouping SERG-SHOW-AGT-STATISTICS {
      description "serg agt stats t";
      container intf-status-statistics {
        description "intf status statistics";
        uses SERG-SHOW-IDB-STATUS-STAT;
      }  // container intf-status-statistics

      container tx-list-statistics {
        description "tx list statistics";
        uses SERG-SHOW-TXLSTAT;
      }  // container tx-list-statistics

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

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

      leaf source-interface-ipv4-address {
        type inet:ipv4-address;
        description
          "Source Interface IPv4 Address";
      }

      leaf source-interface-ipv6-address {
        type inet:ipv6-address;
        description
          "Source Interface IPv6 Address";
      }

      leaf redundancy-role {
        type string;
        description "Redundancy Role";
      }

      leaf restart-client-sync-in-progress {
        type boolean;
        description
          "Restart Client Sync In Progress Flag";
      }

      leaf client-init-sync-time-stamp {
        type string;
        description
          "Synchronization TimeStamp";
      }

      leaf restart-peer-sync-in-progress {
        type boolean;
        description
          "Restart Peer Sync In Progress Flag";
      }

      leaf peer-init-sync-time-stamp {
        type string;
        description
          "Synchronization TimeStamp";
      }

      leaf sync-in-progress {
        type boolean;
        description "Sync In Progress Flag";
      }

      leaf peer-action-timer {
        type uint32;
        units "second";
        description
          "Value in Seconds to trigger the peer actions";
      }

      leaf retry-timer-remaining {
        type uint32;
        units "second";
        description
          "Value in Seconds to trigger the retry";
      }

      leaf tx-list-client-registration-invalid {
        type uint32;
        description
          "TxListClientRegistrationInvalid";
      }

      leaf tx-list-client-de-registration-invalid {
        type uint32;
        description
          "TxListClientDeRegistrationInvalid";
      }

      leaf tx-list-client-connection-up {
        type uint32;
        description
          "TxListClientConnectionUp";
      }

      leaf tx-list-client-connection-down {
        type uint32;
        description
          "TxListClientConnectionDown";
      }

      leaf tx-list-client-peer-done {
        type uint32;
        description "TxListClientPeerDone";
      }

      leaf tx-list-client-message-call-back {
        type uint32;
        description
          "TxListClientMessageCallBack";
      }

      leaf tx-list-client-receive-valid {
        type uint32;
        description
          "TxListClientReceiveValid";
      }

      leaf tx-list-client-receive-invalid {
        type uint32;
        description
          "TxListClientReceiveInValid";
      }

      leaf tx-list-client-receive-command-valid {
        type uint32;
        description
          "TxListClientReceiveCommandValid";
      }

      leaf tx-list-client-receive-command-invalid {
        type uint32;
        description
          "TxListClientReceiveCommandInValid";
      }

      leaf tx-list-client-receive-session-sessionvalid {
        type uint32;
        description
          "TxListClientReceiveSessionSessionValid";
      }

      leaf tx-list-client-receive-session-session-invalid {
        type uint32;
        description
          "TxListClientReceiveSessionSessionInValid";
      }

      leaf tx-list-peer-timer-handler {
        type uint32;
        description "TxListPeerTimerHandler";
      }

      leaf tx-list-peer-registration-invalid {
        type uint32;
        description
          "TxListPeerRegistrationInValid";
      }

      leaf tx-list-peer-de-registration-invalid {
        type uint32;
        description
          "TxListPeerDeRegistrationInValid";
      }

      leaf tx-list-peer-message-call-back-valid {
        type uint32;
        description
          "TxListPeerMessageCallBackValid";
      }

      leaf tx-list-peer-message-call-back-invalid {
        type uint32;
        description
          "TxListPeerMessageCallBackInValid";
      }

      leaf tx-list-peer-done {
        type uint32;
        description "TxListPeerDone";
      }

      leaf tx-list-peer-cmd-connection-up-not-ok {
        type uint32;
        description
          "TxListPeerCmdConnectionUpNotOk";
      }

      leaf tx-list-peer-cmd-connection-down-not-ok {
        type uint32;
        description
          "TxListPeerCmdConnectionDownNotOk";
      }

      leaf tx-list-peer-session-connection-up-not-ok {
        type uint32;
        description
          "TxListPeerSessionConnectionUpNotOk";
      }

      leaf tx-list-peer-session-connection-down-not-ok {
        type uint32;
        description
          "TxListPeerSessionConnectionDownNotOk";
      }

      leaf tx-list-send-pool-update-not-ok {
        type uint32;
        description
          "TxListSendPoolUpdateNotOk";
      }

      list client-status {
        description "Client Status";
        uses SERG-SHOW-AGT-CLIENT-STATUS;
      }  // list client-status

      list opaque-memory-status {
        description "Opaque memory Stats";
        uses SERG-SHOW-OPQ-MEM-STATS;
      }  // list opaque-memory-status

      list tx-list-over-tcp-status {
        description "TCP TxList Statistics";
        uses SERG-SHOW-TXSEND-TCP-STATISTICS;
      }  // list tx-list-over-tcp-status
    }  // grouping SERG-SHOW-AGT-STATISTICS

    grouping SERG-SHOW-AGT-INTF-CLIENT-STATUS {
      description
        "serg show agt intf client status";
      leaf component {
        type Serg-show-comp;
        description "Component";
      }

      leaf serg-show-idb-client-eoms-pending {
        type boolean;
        description
          "SERG SHOW IDB CLIENT EOMS PENDING";
      }

      leaf serg-show-idb-client-sync-eod-pending {
        type boolean;
        description
          "SERG SHOW IDB CLIENT SYNC EOD PENDING";
      }

      leaf session-count {
        type uint32;
        description "session count";
      }
    }  // grouping SERG-SHOW-AGT-INTF-CLIENT-STATUS

    grouping SERG-SHOW-INTF-STATUS {
      description
        "Session Redundancy Interface Status";
      leaf idb-state-fwd-ref {
        type boolean;
        description
          "Interface Forward Referenced";
      }

      leaf idb-state-stale {
        type boolean;
        description "Interface State Stale";
      }

      leaf idb-state-registered {
        type boolean;
        description
          "Interface State Registered";
      }

      leaf idb-state-caps-added {
        type boolean;
        description
          "Interface State Caps Added";
      }

      leaf idb-state-owned-re-source {
        type boolean;
        description
          "Interface State Owned Resource";
      }

      leaf idb-client-eoms-pending {
        type boolean;
        description
          "Interface Client EOMS Pending";
      }

      leaf idb-state-p-end-caps-rem {
        type boolean;
        description
          "Interface Caps Remove Pending";
      }

      leaf idb-state-p-end-reg-disable {
        type boolean;
        description
          "Interface Registration Disable Pending";
      }
    }  // grouping SERG-SHOW-INTF-STATUS

    grouping SERG-SHOW-INTF-OPER {
      description
        "Session Redundancy Interface Operational Status";
      leaf idb-oper-reg-enable {
        type boolean;
        description
          "Operational Registration Enabled";
      }

      leaf idb-oper-reg-disable {
        type boolean;
        description
          "Operational Registration Disabled";
      }

      leaf idb-oper-caps-add {
        type boolean;
        description "Operational Caps Add";
      }

      leaf idb-oper-caps-remove {
        type boolean;
        description
          "Operational Caps Remove";
      }

      leaf idb-oper-attr-update {
        type boolean;
        description
          "Operational Attribute Update";
      }
    }  // grouping SERG-SHOW-INTF-OPER

    grouping SERG-SHOW-AGT-INTF-ENTRY {
      description
        "Session Redundancy Agent Interface Information";
      container interface-oper {
        description
          "Interface Batch Operation";
        uses SERG-SHOW-INTF-OPER;
      }  // container interface-oper

      container interface-status {
        description "Interface Status";
        uses SERG-SHOW-INTF-STATUS;
      }  // container interface-status

      leaf interface-name {
        type string;
        description "Interface Name";
      }

      leaf interface-synchronization-id {
        type uint32;
        description "Interface Sync ID";
      }

      leaf group-id {
        type uint32;
        description "Group ID";
      }

      leaf role {
        type Serg-show-im-role;
        description "SERG Role";
      }

      leaf forward-referenced {
        type boolean;
        description "Forward Referenced";
      }

      leaf session-count {
        type uint32;
        description "Session Count";
      }

      leaf interface-enable-error-count {
        type uint32;
        description
          "Interface Enable Error Count";
      }

      leaf interface-disable-error-count {
        type uint32;
        description
          "Interface Disable Error Count";
      }

      leaf interface-caps-add-error-count {
        type uint32;
        description
          "Interface Caps Add Error Count";
      }

      leaf interface-caps-remove-error-count {
        type uint32;
        description
          "Interface Caps Remove Error Count";
      }

      leaf interface-attribute-update-error-count {
        type uint32;
        description
          "Interface Attribute Update Error Count";
      }

      list client-status {
        description
          "Interface status for each client";
        uses SERG-SHOW-AGT-INTF-CLIENT-STATUS;
      }  // list client-status
    }  // grouping SERG-SHOW-AGT-INTF-ENTRY

    grouping SERG-SHOW-GROUP-POOL-INFO {
      description
        "Session Redundancy Group Interface-List
       Information";
      leaf pool-name {
        type string;
        description "Pool Name";
      }
    }  // grouping SERG-SHOW-GROUP-POOL-INFO

    grouping SERG-SHOW-GROUP-INTF-INFO {
      description
        "Session Redundancy Group Interface-List
       Information";
      leaf interface-name {
        type string;
        description "Interface Name";
      }

      leaf interface-synchronization-id {
        type uint32;
        description
          "Interface Synchronization ID";
      }

      leaf forward-referenced {
        type boolean;
        description "Forward Referenced";
      }

      leaf session-count {
        type uint32;
        description "Session Count";
      }
    }  // grouping SERG-SHOW-GROUP-INTF-INFO

    grouping SERG-SHOW-CLIENT-SESSION-COUNT {
      description
        "Session Redundancy Client Session Count
       Information";
      leaf component {
        type Serg-show-comp;
        description "Component";
      }

      leaf session-count {
        type uint32;
        description "Session count";
      }
    }  // grouping SERG-SHOW-CLIENT-SESSION-COUNT

    grouping SERG-SHOW-GROUP-ENTRY {
      description
        "Session Redundancy Group Information";
      leaf group-id-xr {
        type uint32;
        description "Group ID";
      }

      leaf description {
        type string;
        description "Group Description";
      }

      leaf disabled {
        type boolean;
        description "Disabled by Config";
      }

      leaf init-role {
        type Serg-show-role;
        description "Preferred Init Role";
      }

      leaf negotiating-role {
        type Serg-show-role;
        description "Negotiating Role";
      }

      leaf current-role {
        type Serg-show-role;
        description "Current Role";
      }

      leaf slave-mode {
        type Serg-show-slave-mode;
        description "Slave Mode";
      }

      leaf hold-timer {
        type uint32;
        description "Switch Over Hold Time";
      }

      leaf core-tracking-object-name {
        type string;
        description
          "Core Object Tracking Name";
      }

      leaf core-tracking-object-status {
        type boolean;
        description
          "Core Object Tracking Status";
      }

      leaf access-tracking-object-name {
        type string;
        description
          "Access Object Tracking Name";
      }

      leaf access-tracking-object-status {
        type boolean;
        description
          "Access Object Tracking Status";
      }

      leaf object-tracking-status {
        type boolean;
        description
          "Object Tracking Status (Enabled/Disabled)";
      }

      leaf peer-ipv4-address {
        type inet:ipv4-address;
        description "Peer IPv4 Address";
      }

      leaf peer-ipv6-address {
        type inet:ipv6-address;
        description "Peer IPv6 Address";
      }

      leaf peer-status {
        type Serg-peer-status;
        description "Peer Status";
      }

      leaf peer-last-negotiation-time {
        type string;
        description
          "Last Negotiation time of Peer";
      }

      leaf peer-last-up-time {
        type string;
        description "Last UP time of Peer";
      }

      leaf peer-last-down-time {
        type string;
        description "Last Down time of Peer";
      }

      leaf peer-init-role {
        type Serg-show-role;
        description
          "Peer Preferred Init Role";
      }

      leaf peer-negotiating-role {
        type Serg-show-role;
        description "Peer Negotiating Role";
      }

      leaf peer-current-role {
        type Serg-show-role;
        description "Peer Current Role";
      }

      leaf peer-object-tracking-status {
        type boolean;
        description
          "Peer Object Tracking Status";
      }

      leaf last-switchover-time {
        type string;
        description "Last Switchover time";
      }

      leaf switchover-count {
        type uint32;
        description "Switchover Count";
      }

      leaf last-switchover-reason {
        type Serg-show-so-reason;
        description "Last Switchover Reason";
      }

      leaf switchover-hold-time {
        type uint32;
        units "second";
        description
          "Switchover Hold Time in seconds";
      }

      leaf session-count {
        type uint32;
        description "Session Count";
      }

      leaf slave-update-failure-count {
        type uint32;
        description
          "Slave Session update fail count";
      }

      leaf pending-session-update-count {
        type uint32;
        description
          "Pending Session Update Count";
      }

      leaf pending-session-delete-count {
        type uint32;
        description
          "Pending Session Delete Count";
      }

      leaf interface-count {
        type uint32;
        description
          "No. of Configured Interfaces";
      }

      leaf revertive-timer {
        type uint32;
        description
          "Revertive timer for SWO back";
      }

      leaf switchover-revert-time {
        type uint32;
        units "second";
        description
          "Switchover Revert Time in seconds";
      }

      leaf pool-count {
        type uint32;
        description
          "No. of Configured Pools";
      }

      list client-session-count {
        description "Client Session Count";
        uses SERG-SHOW-CLIENT-SESSION-COUNT;
      }  // list client-session-count

      list interface {
        description "Interface List";
        uses SERG-SHOW-GROUP-INTF-INFO;
      }  // list interface

      list pool {
        description "Pool List";
        uses SERG-SHOW-GROUP-POOL-INFO;
      }  // list pool
    }  // grouping SERG-SHOW-GROUP-ENTRY

    grouping SERG-SHOW-AGT-CLIENT-STATISTICS {
      description "serg agt c stats t";
      leaf tx-list-start-of-download-add-ok {
        type uint32;
        description
          "TxListStartOfDownloadAddOk";
      }

      leaf tx-list-start-of-download-add-not-ok {
        type uint32;
        description
          "TxListStartOfDownloadAddNotOk";
      }

      leaf tx-list-end-of-download-add-ok {
        type uint32;
        description
          "TxListEndOfDownloadAddOk";
      }

      leaf tx-list-end-of-download-add-not-ok {
        type uint32;
        description
          "TxListEndOfDownloadAddNotOk";
      }

      leaf tx-list-end-of-message-add-ok {
        type uint32;
        description
          "TxListEndOfMessageAddOk";
      }

      leaf tx-list-end-of-message-add-not-ok {
        type uint32;
        description
          "TxListEndOfMessageAddNotOk";
      }

      leaf tx-list-clear-all-add-ok {
        type uint32;
        description "TxListClearAllAddOk";
      }

      leaf tx-list-clear-all-add-not-ok {
        type uint32;
        description "TxListClearAllAddNotOk";
      }

      leaf tx-list-clear-selected-add-ok {
        type uint32;
        description
          "TxListClearSelectedAddOk";
      }

      leaf tx-list-clear-selected-add-not-ok {
        type uint32;
        description
          "TxListClearSelectedAddNotOk";
      }

      leaf tx-list-replay-all-add-ok {
        type uint32;
        description "TxListReplayAllAddOk";
      }

      leaf tx-list-replay-all-add-not-ok {
        type uint32;
        description
          "TxListReplayAllAddNotOk";
      }

      leaf tx-list-replay-selected-add-ok {
        type uint32;
        description
          "TxListReplaySelectedAddOk";
      }

      leaf tx-list-replay-selected-add-not-ok {
        type uint32;
        description
          "TxListReplaySelectedAddNotOk";
      }

      leaf tx-list-session-session-add-ok {
        type uint32;
        description
          "TxListSessionSessionAddOk";
      }

      leaf tx-list-session-session-add-not-ok {
        type uint32;
        description
          "TxListSessionSessionAddNotOk";
      }

      leaf tx-list-session-session-update-ok {
        type uint32;
        description
          "TxListSessionSessionUpdateOk";
      }

      leaf tx-list-session-session-update-not-ok {
        type uint32;
        description
          "TxListSessionSessionUpdateNotOk";
      }

      leaf tx-list-session-session-delete {
        type uint32;
        description
          "TxListSessionSessionDelete";
      }

      leaf clean-call-back {
        type uint32;
        description "CleanCallBack";
      }

      leaf tx-list-encode-session-session-ok {
        type uint32;
        description
          "TxListEncodeSessionSessionOk";
      }

      leaf tx-list-encode-session-session-partial-write {
        type uint32;
        description
          "TxListEncodeSessionSessionPartialWrite";
      }

      leaf last-replay-all-count {
        type uint32;
        description "LastReplayAllCount";
      }

      leaf tx-list-receive-command-replay-all {
        type uint32;
        description
          "TxListReceiveCommandReplayAll";
      }

      leaf tx-list-receive-command-replay-selected {
        type uint32;
        description
          "TxListReceiveCommandReplaySelected";
      }

      leaf tx-list-receive-session-session-delete-valid {
        type uint32;
        description
          "TxListReceiveSessionSessionDeleteValid";
      }

      leaf tx-list-receive-session-session-delete-invalid {
        type uint32;
        description
          "TxListReceiveSessionSessionDeleteInValid";
      }

      leaf tx-list-receive-session-session-update-valid {
        type uint32;
        description
          "TxListReceiveSessionSessionUpdateValid";
      }

      leaf tx-list-receive-session-session-update-invalid {
        type uint32;
        description
          "TxListReceiveSessionSessionUpdateInValid";
      }

      leaf tx-list-receive-session-session-sod-all {
        type uint32;
        description
          "TxListReceiveSessionSessionSODAll";
      }

      leaf tx-list-receive-session-session-sod-selected {
        type uint32;
        description
          "TxListReceiveSessionSessionSODSelected";
      }

      leaf tx-list-receive-session-session-eod-all {
        type uint32;
        description
          "TxListReceiveSessionSessionEODAll";
      }

      leaf tx-list-receive-session-session-eod-selected {
        type uint32;
        description
          "TxListReceiveSessionSessionEODSelected";
      }

      leaf tx-list-rx-tcp-restart-start-of-download {
        type uint32;
        description
          "TxListRxTCPRestartStartOfDownload";
      }

      leaf tx-list-rx-tcp-restart-end-of-download {
        type uint32;
        description
          "TxListRxTCPRestartEndOfDownload";
      }

      leaf tx-list-receive-session-session-eoms {
        type uint32;
        description
          "TxListReceiveSessionSessionEOMS";
      }

      leaf tx-list-receive-session-session-clear-all {
        type uint32;
        description
          "TxListReceiveSessionSessionClearAll";
      }

      leaf tx-list-receive-session-session-clear-selected {
        type uint32;
        description
          "TxListReceiveSessionSessionClearSelected";
      }

      leaf tx-list-receive-session-session-neg-ack {
        type uint32;
        description
          "TxListReceiveSessionSessionNegAck";
      }

      leaf tx-list-receive-session-session-neg-ack-not-ok {
        type uint32;
        description
          "TxListReceiveSessionSessionNegAckNotOk";
      }

      leaf tx-list-client-registration-ok {
        type uint32;
        description
          "TxListClientRegistrationOk";
      }

      leaf tx-list-client-registration-not-ok {
        type uint32;
        description
          "TxListClientRegistrationNotOk";
      }

      leaf tx-list-client-de-registration {
        type uint32;
        description
          "TxListClientDeRegistration";
      }

      leaf tx-list-client-connection-down {
        type uint32;
        description
          "TxListClientConnectionDown";
      }

      leaf tx-list-client-cleanup {
        type uint32;
        description "TxListClientCleanup";
      }

      leaf tx-list-active-ok {
        type uint32;
        description "TxListActiveOk";
      }

      leaf tx-list-active-not-ok {
        type uint32;
        description "TxListActiveNotOk";
      }

      leaf tx-list-de-active-ok {
        type uint32;
        description "TxListDeActiveOk";
      }

      leaf tx-list-de-active-not-ok {
        type uint32;
        description "TxListDeActiveNotOk";
      }

      leaf tx-list-send-pool-role-ok {
        type uint32;
        description "TxListSendPoolRoleOk";
      }

      leaf tx-list-send-pool-role-not-ok {
        type uint32;
        description
          "TxListSendPoolRoleNotOk";
      }

      leaf tx-list-send-pool-update-ok {
        type uint32;
        description "TxListSendPoolUpdateOk";
      }

      leaf tx-list-send-pool-update-not-ok {
        type uint32;
        description
          "TxListSendPoolUpdateNotOk";
      }

      leaf tx-list-recv-pool-update-ok {
        type uint32;
        description "TxListRecvPoolUpdateOk";
      }
    }  // grouping SERG-SHOW-AGT-CLIENT-STATISTICS

    grouping SERG-SHOW-SESSION-ERROR-INFO {
      description
        "Session Redundancy Session Verbose Client Error
       Information";
      leaf sync-error-count {
        type uint16;
        description
          "No. of Errors occured during Synchronization";
      }

      leaf last-error-code {
        type uint32;
        description "Last Error Code";
      }

      leaf last-error-type {
        type Serg-show-session-error;
        description "Last Error Type";
      }
    }  // grouping SERG-SHOW-SESSION-ERROR-INFO

    grouping SERG-SHOW-SESSION-CLIENT {
      description
        "Session Redundancy Session Verbose Client
       Information";
      leaf component {
        type Serg-show-comp;
        description "Component";
      }

      leaf operation {
        type Serg-show-session-operation;
        description "Operation Code";
      }

      leaf tx-list-queue-fail {
        type boolean;
        description "Tx List Queue Failed";
      }

      leaf marked-for-sweeping {
        type boolean;
        description "Marked For Sweeping";
      }

      leaf marked-for-cleanup {
        type boolean;
        description "Marked For Cleanup";
      }
    }  // grouping SERG-SHOW-SESSION-CLIENT

    grouping SERG-SHOW-SESSION-ENTRY {
      description
        "Session Redundancy Session Information";
      leaf group-id-xr {
        type uint32;
        description "Group ID";
      }

      leaf interface-name {
        type string;
        description "Interface Name";
      }

      leaf key-index {
        type string;
        description "Key index";
      }

      leaf role-master {
        type boolean;
        description "Master Role is Set";
      }

      leaf role-active {
        type boolean;
        description "Active Role is Set";
      }

      leaf negative-acknowledgement-update-all {
        type boolean;
        description
          "Negative Acknowledgement Update Flag is Set";
      }

      leaf entry-type {
        type boolean;
        description "Local or Sync Entry";
      }

      list session-detailed-information {
        description
          "More Session Information";
        uses SERG-SHOW-SESSION-CLIENT;
      }  // list session-detailed-information

      list session-sync-error-information {
        description
          "Session Synchroniation Error Information";
        uses SERG-SHOW-SESSION-ERROR-INFO;
      }  // list session-sync-error-information
    }  // grouping SERG-SHOW-SESSION-ENTRY

    grouping SERG-SHOW-MGR-SUMMARY {
      description
        "Session Redundancy Manager Summary Information";
      leaf disabled {
        type boolean;
        description "Disabled by Config";
      }

      leaf active-state {
        type boolean;
        description "Process Active State";
      }

      leaf preferred-role {
        type Serg-show-role;
        description "Preferred Role";
      }

      leaf slave-mode {
        type Serg-show-slave-mode;
        description "Slave Mode";
      }

      leaf hold-timer {
        type uint32;
        description "Switch Over Hold Time";
      }

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

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

      leaf source-interface-ipv4-address {
        type inet:ipv4-address;
        description
          "Source Interface IPv4 Address";
      }

      leaf source-interface-ipv6-address {
        type inet:ipv6-address;
        description
          "Source Interface IPv6 Address";
      }

      leaf group-count {
        type uint32;
        description
          "No. of Configured Groups";
      }

      leaf disabled-group-count {
        type uint32;
        description
          "No. of Disabled Groups by Config";
      }

      leaf master-group-count {
        type uint32;
        description
          "No. of Master/Active Groups";
      }

      leaf slave-group-count {
        type uint32;
        description "No. of Slave Groups";
      }

      leaf active-group-count {
        type uint32;
        description "No. of Active Groups";
      }

      leaf interface-count {
        type uint32;
        description
          "No. of Configured Interfaces";
      }

      leaf master-interface-count {
        type uint32;
        description
          "No. of Master/Active Interfaces";
      }

      leaf slave-interface-count {
        type uint32;
        description
          "No. of Slave Interfaces";
      }

      leaf active-interface-count {
        type uint32;
        description
          "No. of Active Interfaces";
      }

      leaf pool-count {
        type uint32;
        description
          "No. of Configured Pools";
      }
    }  // grouping SERG-SHOW-MGR-SUMMARY

    grouping SERG-SHOW-MGR-GROUP-ENTRY {
      description
        "Session Redundancy Manager Group Information";
      leaf group-id {
        type uint32;
        description "Group ID";
      }

      leaf description {
        type string;
        description "Group Description";
      }

      leaf disabled {
        type boolean;
        description "Disabled by Config";
      }

      leaf role {
        type Serg-show-im-role;
        description "SERG Role";
      }

      leaf peer-ipv4-address {
        type inet:ipv4-address;
        description "Peer IPv4 Address";
      }

      leaf peer-ipv6-address {
        type inet:ipv6-address;
        description "Peer IPv6 Address";
      }

      leaf interface-count {
        type uint32;
        description "Interface Count";
      }

      leaf preferred-role {
        type Serg-show-role;
        description "Preferred Role";
      }

      leaf slave-mode {
        type Serg-show-slave-mode;
        description "Slave Mode";
      }

      leaf object-tracking-status {
        type boolean;
        description
          "Object Tracking Status (Enabled/Disabled)";
      }

      leaf node-name {
        type string;
        description "Node Information";
      }
    }  // grouping SERG-SHOW-MGR-GROUP-ENTRY

    grouping SERG-SHOW-MGR-INTF-ENTRY {
      description
        "Session Redundancy Manager Interface Information";
      leaf interface-name {
        type string;
        description "Interface Name";
      }

      leaf interface-mapping-id {
        type uint32;
        description "Interface Mapping ID";
      }

      leaf forward-referenced {
        type boolean;
        description "Forward Referenced";
      }

      leaf group-id {
        type uint32;
        description "Group ID";
      }

      leaf role {
        type Serg-show-im-role;
        description "SERG Role";
      }
    }  // grouping SERG-SHOW-MGR-INTF-ENTRY
  }  // submodule Cisco-IOS-XR-infra-serg-oper-sub1