module Cisco-IOS-XR-subscriber-srg-oper {

    yang-version 1;

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

    prefix subscriber-srg-oper;

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

    include Cisco-IOS-XR-subscriber-srg-oper-sub1 {
      revision-date "2019-10-03";
    }

    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 subscriber-srg package operational data.
     
     This module contains definitions
     for the following management objects:
       subscriber-redundancy-manager: Subscriber Redundancy Manager
         information
       subscriber-redundancy-agent: Subscriber Redundancy Agent
         information
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-10-03" {
      description
        "added new bags and bag elements in srg-show bag.";
    }

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

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

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

    container subscriber-redundancy-manager {
      config false;
      description
        "Subscriber Redundancy Manager information";
      container groups {
        description
          "Subscriber Redundancy Manager group table";
        list group {
          key "group";
          description
            "Subscriber 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 Srg-show-im-role;
            description "SRG 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 Srg-show-role;
            description "Preferred Role";
          }

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

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

          leaf virtual-mac-address {
            type string;
            description
              "Virtual MAC Address";
          }

          leaf virtual-mac-address-disable {
            type boolean;
            description
              "Virtual MAC Address Disable";
          }

          leaf node-name {
            type string;
            description "Node Information";
          }
        }  // list group
      }  // container groups

      container summary {
        description
          "Subscriber redundancy manager summary";
        leaf disabled {
          type boolean;
          description "Disabled by Config";
        }

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

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

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

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

        leaf sync-time {
          type uint32;
          description "Sync 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 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";
        }
      }  // container summary

      container interfaces {
        description
          "Subscriber Redundancy Manager interface table";
        list interface {
          key "interface";
          description
            "Subscriber 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 Srg-show-im-role;
            description "SRG Role";
          }
        }  // list interface
      }  // container interfaces
    }  // container subscriber-redundancy-manager

    container subscriber-redundancy-agent {
      config false;
      description
        "Subscriber Redundancy Agent information";
      container nodes {
        description
          "List of nodes for which subscriber data is
         collected";
        list node {
          key "node-name";
          description
            "Subscriber data for a particular node";
          container peer-summaries {
            description
              "List of peer objects";
            list peer-summary {
              key "peer-name";
              description
                "Subscriber redundancy agent peer summary";
              leaf peer-name {
                type xr:Cisco-ios-xr-string;
                description "PeerName";
              }

              leaf name {
                type string;
                description "Object Name";
              }

              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 tcp-port {
                type uint32;
                description "TCP port";
              }

              leaf peer-status {
                type Srg-peer-status;
                description "Peer Status";
              }
            }  // list peer-summary
          }  // container peer-summaries

          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 outer-vlan {
                type uint32;
                description
                  "Outer VLAN Information";
              }

              leaf inner-vlan {
                type uint32;
                description
                  "Inner VLAN Information";
              }

              leaf session-mac-address {
                type string;
                description
                  "Session MAC Address";
              }

              leaf pppoe-session-id {
                type uint16;
                description
                  "PPPoE Session ID";
              }

              leaf l2tp-tunnel-id {
                type uint32;
                description
                  "L2TP Tunnel local ID";
              }

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

              leaf valid-mac-address {
                type boolean;
                description
                  "Holds a Valid MAC Address";
              }

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

              list session-detailed-information {
                description
                  "More Session Information";
                leaf component {
                  type Srg-show-comp;
                  description "Component";
                }

                leaf operation {
                  type Srg-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 Srg-show-session-error;
                  description
                    "Last Error Type";
                }
              }  // list session-sync-error-information
            }  // list group-id
          }  // container group-id-xr

          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

              container event-history {
                description
                  "Event history of interface";
                leaf evt-class-name {
                  type string;
                  description
                    "Class name string";
                }

                list evt-entry {
                  description
                    "Array of event entries";
                  leaf evt-timestamp {
                    type string;
                    description
                      "The timestamp of the event";
                  }

                  leaf evt-name {
                    type string;
                    description "Event name";
                  }

                  leaf evt-type {
                    type uint8;
                    description "Event type";
                  }

                  leaf evt-many {
                    type boolean;
                    description
                      "Multiple instance flag";
                  }

                  leaf evt-sticky {
                    type boolean;
                    description
                      "Sticky flag";
                  }

                  leaf-list evt-data {
                    type uint32;
                    description
                      "Optional data";
                  }
                }  // list evt-entry
              }  // container event-history

              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 Srg-show-im-role;
                description "SRG 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 Srg-show-comp;
                  description "Component";
                }

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

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

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

              list history {
                description
                  "IDB statistics history";
                container time-updated {
                  description
                    "Time stamp when the stats was updated";
                  leaf seconds {
                    type uint32;
                    units "second";
                    description
                      "Number of seconds";
                  }
                }  // container time-updated

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

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

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

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

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

                leaf-list client-status-hist {
                  type uint8;
                  description
                    "Interface status history for each client";
                }

                leaf-list client-count-hist {
                  type uint32;
                  description
                    "Session count history per client";
                }
              }  // list history
            }  // list interface
          }  // container interfaces

          container group-summaries {
            description
              "Subscriber data for a particular node";
            list group-summary {
              key "group-id";
              description
                "Subscriber 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 Srg-show-im-role;
                description "SRG 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-name {
                type string;
                description "Peer name";
              }

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

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

              leaf slave-mode {
                type Srg-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

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

              container event-history {
                description
                  "Event history of group";
                leaf evt-class-name {
                  type string;
                  description
                    "Class name string";
                }

                list evt-entry {
                  description
                    "Array of event entries";
                  leaf evt-timestamp {
                    type string;
                    description
                      "The timestamp of the event";
                  }

                  leaf evt-name {
                    type string;
                    description "Event name";
                  }

                  leaf evt-type {
                    type uint8;
                    description "Event type";
                  }

                  leaf evt-many {
                    type boolean;
                    description
                      "Multiple instance flag";
                  }

                  leaf evt-sticky {
                    type boolean;
                    description
                      "Sticky flag";
                  }

                  leaf-list evt-data {
                    type uint32;
                    description
                      "Optional data";
                  }
                }  // list evt-entry
              }  // container event-history

              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 Srg-show-role;
                description
                  "Preferred Init Role";
              }

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

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

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

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

              leaf virtual-mac-address {
                type string;
                description
                  "Virtual MAC Address";
              }

              leaf virtual-mac-address-disable {
                type boolean;
                description
                  "Virtual MAC Address Disable";
              }

              leaf l2tp-source-ip {
                type inet:ipv4-address;
                description
                  "L2TP Souce IP Address";
              }

              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-name {
                type string;
                description "Peer name";
              }

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

              leaf peer-last-negotiation-time-epoch {
                type uint64;
                units "second";
                description
                  "Last Negotiation time of Peer in epoch seconds";
              }

              leaf peer-last-up-time-epoch {
                type uint64;
                units "second";
                description
                  "Last UP time of Peer in epoch seconds";
              }

              leaf peer-last-down-time-epoch {
                type uint64;
                units "second";
                description
                  "Last Down time of Peer in epoch seconds";
              }

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

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

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

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

              leaf last-switchover-time-epoch {
                type uint64;
                units "second";
                description
                  "Last Switchover time in epoch seconds";
              }

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

              leaf last-switchover-reason {
                type Srg-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 tunnel-count {
                type uint32;
                description "Tunnel 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 last-hitory-index {
                type uint8;
                description
                  "Index of last switchover timestamp";
              }

              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 history-array {
                description
                  "Array of switchover history ";
                leaf group-switchover-time {
                  type uint64;
                  description
                    "Group Switchover Time";
                }

                leaf role {
                  type Srg-show-im-role;
                  description "SRG Role";
                }

                leaf reason {
                  type Srg-show-so-reason;
                  description
                    "Switchover reason";
                }
              }  // list history-array

              list route-ipv4-array {
                description
                  "Array of ipv4 static route";
                leaf vrf-name {
                  type string {
                    length "0..33";
                  }
                  description "vrf name";
                }

                leaf prefix-len {
                  type uint8;
                  description "prefix len";
                }

                leaf ipv4 {
                  type inet:ipv4-address;
                  description "ipv4";
                }

                leaf tag {
                  type uint32;
                  description "tag";
                }
              }  // list route-ipv4-array

              list route-ipv6-array {
                description
                  "Array of ipv6 static route";
                leaf ipv6 {
                  type inet:ipv6-address;
                  description "ipv6";
                }

                leaf vrf-name {
                  type string {
                    length "0..33";
                  }
                  description "vrf name";
                }

                leaf prefix-len {
                  type uint8;
                  description "prefix len";
                }

                leaf type {
                  type uint8;
                  description "type";
                }

                leaf tag {
                  type uint32;
                  description "tag";
                }
              }  // list route-ipv6-array
            }  // list group-id
          }  // container group-ids

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