module Cisco-IOS-XR-infra-serg-oper {

    yang-version 1;

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

    prefix infra-serg-oper;

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

    include Cisco-IOS-XR-infra-serg-oper-sub2 {
      revision-date "2019-04-05";
    }
    include Cisco-IOS-XR-infra-serg-oper-sub1 {
      revision-date "2019-04-05";
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
Customer Service

Postal: 170 West Tasman Drive
San Jose, CA 95134

Tel: +1 800 553-NETS

E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
for Cisco IOS-XR infra-serg package operational data.

This module contains definitions
for the following management objects:
  session-redundancy-manager: Session Redundancy Manager
    information
  session-redundancy-agent: Session Redundancy Agent information

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

    container session-redundancy-manager {
      config false;
      description
        "Session Redundancy Manager information";
      container interfaces {
        description
          "Subscriber Redundancy Manager interface table";
        list interface {
          key "interface";
          description
            "interface redundancy manager interface";
          leaf interface {
            type xr:Cisco-ios-xr-string;
            description "Interface";
          }

          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";
          }
        }  // list interface
      }  // container interfaces

      container groups {
        description
          "Session Redundancy Manager group table";
        list group {
          key "group";
          description
            "Session redundancy manager group";
          leaf group {
            type xr:Cisco-ios-xr-string;
            description "Group";
          }

          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";
          }
        }  // list group
      }  // container groups

      container summary {
        description
          "Session redundancy manager summary";
        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";
        }
      }  // container summary
    }  // container session-redundancy-manager

    container session-redundancy-agent {
      config false;
      description
        "Session Redundancy Agent information";
      container nodes {
        description
          "List of nodes for which session data is
collected";
        list node {
          key "node-name";
          description
            "Session data for a particular node";
          container group-id-xr {
            description
              "Data for particular subscriber group session";
            list group-id {
              key "group-id";
              description
                "Group id for subscriber group session";
              leaf group-id {
                type xr:Cisco-ios-xr-string;
                description "GroupId";
              }

              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";
                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";
                }
              }  // list session-detailed-information

              list session-sync-error-information {
                description
                  "Session Synchroniation 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";
                }
              }  // list session-sync-error-information
            }  // list group-id
          }  // container group-id-xr

          container client-ids {
            description "Stats Client";
            list client-id {
              key "stats-client-id";
              description
                "Specify stats client";
              leaf stats-client-id {
                type uint32;
                description "Client Id";
              }

              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";
              }
            }  // list client-id
          }  // container client-ids

          container memory {
            description "Show Memory";
            list memory-info {
              description "Memory Info";
              leaf structure-name {
                type string;
                description "Structure Name";
              }

              leaf size {
                type uint32;
                description
                  "Size of the datastructure";
              }

              leaf current-count {
                type uint32;
                description "Current Count";
              }

              leaf alloc-fails {
                type uint32;
                description
                  "Allocation Fails";
              }

              leaf alloc-count {
                type uint32;
                description
                  "Allocated count";
              }

              leaf freed-count {
                type uint32;
                description "Freed Count";
              }

              leaf memory-type {
                type Serg-show-mem;
                description "Memory Type";
              }
            }  // list memory-info

            list edm-memory-info {
              description "EDM Memory Info";
              leaf size {
                type uint32;
                description
                  "Size of the block";
              }

              leaf total {
                type uint32;
                description "Total request";
              }

              leaf success {
                type uint32;
                description
                  "Cache-hit success";
              }

              leaf failure {
                type uint32;
                description
                  "Cache-hit failure";
              }
            }  // list edm-memory-info

            list string-memory-info {
              description
                "String Memory Info";
              leaf size {
                type uint32;
                description
                  "Size of the block";
              }

              leaf total {
                type uint32;
                description "Total request";
              }

              leaf success {
                type uint32;
                description
                  "Cache-hit success";
              }

              leaf failure {
                type uint32;
                description
                  "Cache-hit failure";
              }
            }  // list string-memory-info
          }  // container memory

          container group-ids {
            description
              "Data for particular subscriber group ";
            list group-id {
              key "group-id";
              description
                "Group id for subscriber group";
              leaf group-id {
                type xr:Cisco-ios-xr-string;
                description "Group Id";
              }

              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";
                leaf component {
                  type Serg-show-comp;
                  description "Component";
                }

                leaf session-count {
                  type uint32;
                  description
                    "Session count";
                }
              }  // list client-session-count

              list interface {
                description "Interface List";
                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";
                }
              }  // list interface

              list pool {
                description "Pool List";
                leaf pool-name {
                  type string;
                  description "Pool Name";
                }
              }  // list pool
            }  // list group-id
          }  // container group-ids

          container interfaces {
            description "List of interfaces";
            list interface {
              key "interface";
              description
                "Specify interface name";
              leaf interface {
                type xr:Interface-name;
                description "Interface";
              }

              container interface-oper {
                description
                  "Interface Batch Operation";
                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";
                }
              }  // container interface-oper

              container interface-status {
                description
                  "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";
                }
              }  // 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";
                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";
                }
              }  // list client-status
            }  // list interface
          }  // container interfaces

          container stats-global {
            description "Stats Global";
            container intf-status-statistics {
              description
                "intf status statistics";
              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";
              }
            }  // container intf-status-statistics

            container tx-list-statistics {
              description
                "tx list statistics";
              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";
              }
            }  // 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";
              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";
              }
            }  // list client-status

            list opaque-memory-status {
              description
                "Opaque memory 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";
              }
            }  // list opaque-memory-status

            list tx-list-over-tcp-status {
              description
                "TCP TxList Statistics";
              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";
              }
            }  // list tx-list-over-tcp-status
          }  // container stats-global

          container group-summaries {
            description
              "Session data for a particular node";
            list group-summary {
              key "group-id";
              description
                "Session redundancy agent group summary";
              leaf group-id {
                type xr:Cisco-ios-xr-string;
                description "GroupId";
              }

              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";
              }
            }  // list group-summary
          }  // container group-summaries

          leaf node-name {
            type xr:Node-id;
            description "Node name";
          }
        }  // list node
      }  // container nodes
    }  // container session-redundancy-agent
  }  // module Cisco-IOS-XR-infra-serg-oper