submodule Cisco-IOS-XR-ipv4-ospf-oper-sub3 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-ipv4-ospf-oper {
        prefix Cisco-IOS-XR-ipv4-ospf-oper;
    }

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

    include Cisco-IOS-XR-ipv4-ospf-oper-sub2 {
      revision-date "2021-06-01";
    }

    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 ipv4-ospf package operational data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-06-01" {
      description
        "Added changes to show if a FAD contains unknown parameters
       2020-09-15
         Added changes for Delay Anomaly
       2020-07-15
         Added changes for SRTE automatic path capability";
    }

    revision "2020-03-19" {
      description
        "Added changes for Delay Normalization
       2020-02-04
       Added changes for Conditional Advertising
       2019-09-30
       Added changes for Weighted SRLG";
    }

    revision "2019-07-26" {
      description
        "Added new fields in redistribution container to display more information.";
    }

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

    revision "2019-01-07" {
      description
        "Modified for Programmability 2.0";
    }

    revision "2018-04-18" {
      description
        "Added keychain name to be displayed in show ospf interface bag";
    }

    revision "2017-10-26" {
      description
        "Fixed some field name and values for better interpretation";
    }

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

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

    revision "2017-01-02" {
      description "IOS XR 6.2.1 revision.";
    }

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

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

    typedef Ospf-string-array {
      type string;
      description "Ospf string array";
    }

    grouping OSPF-SH-IF-STATS-ENTRY {
      description
        "OSPF interface entry for statistics";
      leaf madj-intf {
        type boolean;
        description "OSPF madj interface";
      }

      leaf area-id {
        type uint32;
        description "OSPF area id";
      }

      leaf area-id-str {
        type string;
        description "OSPF aread id string";
      }

      list if-stat {
        description
          "OSPF interface statistics";
        leaf entry {
          type uint32;
          description
            "OSPF interface statistics";
        }
      }  // list if-stat
    }  // grouping OSPF-SH-IF-STATS-ENTRY

    grouping OSPF-SH-IF-STATS {
      description
        "OSPF interface statistics";
      leaf handle {
        type xr:Interface-name;
        description "interface handle type";
      }

      leaf if-name-str {
        type string;
        description "interface name";
      }

      list if-entry {
        description "interface entry";
        uses OSPF-SH-IF-STATS-ENTRY;
      }  // list if-entry
    }  // grouping OSPF-SH-IF-STATS

    grouping OSPF-SH-RAW-STATS {
      description "OSPF SH RAW STATS";
      leaf out-sent {
        type uint32;
        description
          "Count of packets sent out on raw socket";
      }

      leaf bytes-sent {
        type uint32;
        units "byte";
        description
          "Count of bytes sent out on raw socket";
      }

      leaf out-discarded-no-connection {
        type uint32;
        description
          "Count of outgoing packets discarded due to
         connection issues";
      }

      leaf out-null-src-discarded {
        type uint32;
        description
          "Count of outgoing packets discarded due to
         source address or packet length issues";
      }

      leaf out-no-pakbuf-discarded {
        type uint32;
        description
          "Count of outgoing packets discarded due to
         packet buffer issues";
      }

      leaf out-ipv4-hdr-error-discarded {
        type uint32;
        description
          "Count of outgoing packets discarded due to ipv4
         deader construction failure";
      }

      leaf out-send-pak-error-discarded {
        type uint32;
        description
          "Count of outgoing packets discarded due to send
         failure";
      }

      leaf in-received {
        type uint32;
        description
          "Count of packets received on raw socket";
      }

      leaf bytes-received {
        type uint32;
        units "byte";
        description
          "Count of bytes received on raw socket";
      }

      leaf short-msg-received {
        type uint32;
        description
          "Count of received packets discarded due to
         packet size too small";
      }

      leaf in-no-memory-discarded {
        type uint32;
        description
          "Count of received packets discarded due to
         malloc failure";
      }

      leaf in-raw-events {
        type uint32;
        description
          "Count of incoming raw events";
      }

      leaf disconnects {
        type uint32;
        description
          "Count of raw sockets disconnected";
      }

      leaf in-standby-discarded {
        type uint32;
        description
          "Count of received packets discarded since
         received on standby";
      }

      leaf nsr-not-ready-discarded {
        type uint32;
        description
          "Count of received packets discarded since NSR
         not ready";
      }

      leaf raw-connected {
        type boolean;
        description
          "Whether raw socket connection is up";
      }

      leaf shamlink-raw-connected {
        type boolean;
        description
          "Whether shamlink raw socket connection is up";
      }
    }  // grouping OSPF-SH-RAW-STATS

    grouping OSPF-SH-PROTOPKT-STATS {
      description "OSPF SH PROTOPKT STATS";
      leaf inputs {
        type uint32;
        description
          "Total count of incoming packets";
      }

      leaf input-hello {
        type uint32;
        description
          "Total count of incoming hello packets";
      }

      leaf input-db-descriptions {
        type uint32;
        description
          "Total count of incoming Database description
         packets";
      }

      leaf input-db-descriptions-lsa {
        type uint32;
        description
          "Total count of incoming Database description
         packets with LSA headers";
      }

      leaf input-requests {
        type uint32;
        description
          "Total count of incoming Request packets";
      }

      leaf input-requests-lsa {
        type uint32;
        description
          "Total count of incoming Request packets with LSA
         headers";
      }

      leaf input-ls-updates {
        type uint32;
        description
          "Total count of incoming LS Update packets";
      }

      leaf input-ls-updates-lsa {
        type uint32;
        description
          "Total count of incoming LS Update packets with
         LSA headers";
      }

      leaf input-ls-acks {
        type uint32;
        description
          "Total count of incoming LS Acknowledgement
         packets";
      }

      leaf input-ls-acks-lsa {
        type uint32;
        description
          "Total count of incoming LS Acknowledgement
         packets with LSA headers";
      }

      leaf checksum-errors {
        type uint32;
        description
          "Total count of incoming packets with checksum
         errors";
      }

      leaf input-auth-error {
        type uint32;
        description
          "Total count of incoming packets with
         authentication errors";
      }

      leaf outputs {
        type uint32;
        description
          "Total count of outgoing packets";
      }

      leaf output-hellos {
        type uint32;
        description
          "Total count of outgoing hello packets";
      }

      leaf output-db-descriptions {
        type uint32;
        description
          "Total count of outgoing Database description
         packets";
      }

      leaf output-db-descriptions-lsa {
        type uint32;
        description
          "Total count of outgoing Database description
         packets with LSA headers";
      }

      leaf output-requests {
        type uint32;
        description
          "Total count of outgoing Request packets";
      }

      leaf output-requests-lsa {
        type uint32;
        description
          "Total count of outgoing Request packets with LSA
         headers";
      }

      leaf output-ls-updates {
        type uint32;
        description
          "Total count of outgoing LS Update packets";
      }

      leaf output-ls-updates-lsa {
        type uint32;
        description
          "Total count of outgoing LS Update packets with
         LSA headers";
      }

      leaf output-ls-acks {
        type uint32;
        description
          "Total count of outgoing LS Acknowledgement
         packets";
      }

      leaf output-ls-acks-lsa {
        type uint32;
        description
          "Total count of outgoing LS Acknowledgement
         packets with LSA headers";
      }

      leaf outputs-auth-error {
        type uint32;
        description
          "Total count of outgoing packets with
         authentication errors";
      }

      leaf input-hello-db-descriptions {
        type uint32;
        description
          "Total count of incoming Database description
         packets received on hello thread";
      }

      leaf input-hello-ls-requests {
        type uint32;
        description
          "Total count of incoming Request packets received
         on hello thread";
      }

      leaf input-hello-ls-updates {
        type uint32;
        description
          "Total count of incoming LS Update packets
         received on hello thread";
      }

      leaf input-hello-ls-acks {
        type uint32;
        description
          "Total count of incoming LS Acknowledgement
         packets received on hello thread";
      }
    }  // grouping OSPF-SH-PROTOPKT-STATS

    grouping OSPF-SH-TE-STATS {
      description "OSPF SH TE STATS";
      leaf te-connected {
        type boolean;
        description
          "Whether connection to TE is up or not";
      }

      leaf control-disconnects {
        type uint32;
        description
          "Count of Control disconnects";
      }

      leaf te-disconnects {
        type uint32;
        description
          "Count of Control disconnects";
      }

      leaf adj-gets {
        type uint32;
        description
          "Count of Adjacencies received";
      }

      leaf link-floods {
        type uint32;
        description
          "Count of Link floods received";
      }

      leaf link-fragment-floods {
        type uint32;
        description
          "Count of Link fragments received";
      }

      leaf lsp-gets {
        type uint32;
        description
          "Count of LSP Gets received";
      }

      leaf tunnel-announces {
        type uint32;
        description
          "Count of tunnels announced";
      }

      leaf total-tunnels {
        type uint32;
        description "Total count of tunnels";
      }

      leaf control-batch-reads {
        type uint32;
        description
          "Count of reads of control batch";
      }

      leaf control-batch-writes {
        type uint32;
        description
          "Count of writes of control batch";
      }

      leaf link-batch-reads {
        type uint32;
        description
          "Count of reads of link batch";
      }

      leaf link-batch-writes {
        type uint32;
        description
          "Count of writes of link batch";
      }

      leaf adj-changes {
        type uint32;
        description
          "Count of adjacency changes";
      }

      leaf fragment-deletes {
        type uint32;
        description
          "Count of deleted fragments";
      }

      leaf fragment-announces {
        type uint32;
        description
          "Count of fragments announced";
      }

      leaf data-transfer-completes {
        type uint32;
        description
          "Count of data transfer complete event";
      }

      leaf pce-listen {
        type uint32;
        description
          "Count of PCE listen TRUE events ";
      }

      leaf pce-stoplisten {
        type uint32;
        description
          "Count of PCE listen FALSE events ";
      }

      leaf pce-flood {
        type uint32;
        description
          "Count of PCE flood events";
      }

      leaf pce-get {
        type uint32;
        description
          "Count of PCE get events";
      }

      leaf pce-border-router-lookup {
        type uint32;
        description
          "Count of PCE Border Router Lookup requests";
      }

      leaf pce-border-router-lookup-destinations {
        type uint32;
        description
          "Count of destinations looked up by PCE Border
         Router Lookup requests";
      }

      leaf pce-failure-responses {
        type uint32;
        description
          "Count of PCE failures encountered";
      }

      leaf pce-node-announce-batches {
        type uint32;
        description
          "Count of PCE Node Announce batches";
      }

      leaf pce-node-delete-batches {
        type uint32;
        description
          "Count of PCE Node Announce batches";
      }

      leaf pce-node-announce {
        type uint32;
        description
          "Count of total PCE Node Announces";
      }

      leaf pce-node-delete {
        type uint32;
        description
          "Count of total PCE Node Deletions";
      }

      leaf pce-node-send-fails {
        type uint32;
        description
          "Count of PCE send failures";
      }

      leaf te-sr-path-reg-idt-received {
        type boolean;
        description
          "Whether IDT registrations received for SR TE
         paths";
      }

      leaf te-sr-idt-sent {
        type boolean;
        description
          "Whether IDT message is sent for SR TE";
      }

      leaf sr-area-enabled {
        type uint32;
        description
          "Count of SR enabled areas";
      }
    }  // grouping OSPF-SH-TE-STATS

    grouping OSPF-SH-IPFRR-STATS {
      description "OSPF SH IPFRR STATS";
      leaf fs-paths {
        type uint32;
        description "Number of IPFRR paths";
      }

      leaf fs-paths-eligible {
        type uint32;
        description
          "Number of paths enabled for protection";
      }

      leaf fs-paths-protected {
        type uint32;
        description
          "Number of paths protected";
      }
    }  // grouping OSPF-SH-IPFRR-STATS

    grouping NSR-PL-RECV-DROP-ARRAY {
      description
        "Drop count while receiving messages";
      list nsr-pl-recv-drop-array {
        max-elements 16;
        description "nsr pl recv drop array";
        leaf entry {
          type uint32;
          description "entry";
        }
      }  // list nsr-pl-recv-drop-array
    }  // grouping NSR-PL-RECV-DROP-ARRAY

    grouping NSR-PL-SEND-DROP-ARRAY {
      description
        "Drop count while sending messages";
      list nsr-pl-send-drop-array {
        max-elements 7;
        description "nsr pl send drop array";
        leaf entry {
          type uint32;
          description "entry";
        }
      }  // list nsr-pl-send-drop-array
    }  // grouping NSR-PL-SEND-DROP-ARRAY

    grouping NSR-PL-CLIENT-STATS-TYPE {
      description "NSR PL stats information";
      leaf prio-queue-level {
        type string {
          length "0..32";
        }
        description
          "npl priority queue level";
      }

      list num-sent {
        max-elements 5;
        description "Total sent";
        leaf entry {
          type uint64;
          description "Total sent";
        }
      }  // list num-sent

      list num-recv {
        max-elements 6;
        description "Total recvd";
        leaf entry {
          type uint64;
          description "Total recvd";
        }
      }  // list num-recv

      list num-sent-drop {
        max-elements 5;
        description "Sent Error/drops";
        uses NSR-PL-SEND-DROP-ARRAY;
      }  // list num-sent-drop

      list num-recv-drop {
        max-elements 6;
        description "Recv Errors/drops";
        uses NSR-PL-RECV-DROP-ARRAY;
      }  // list num-recv-drop
    }  // grouping NSR-PL-CLIENT-STATS-TYPE

    grouping OSPF-SH-NCD-STATS {
      description "OSPF SH NCD STATS";
      list npl-priority {
        max-elements 2;
        description
          "NPL Library statistics for each priority level";
        uses NSR-PL-CLIENT-STATS-TYPE;
      }  // list npl-priority
    }  // grouping OSPF-SH-NCD-STATS

    grouping OSPF-SH-STATS-RIB-THREAD {
      description "OSPF SH STATS RIB THREAD";
      container rib-base-time {
        description
          "Base time stamp needed to calculate the current
         time ";
        uses BAG-TIMESPEC;
      }  // container rib-base-time

      container spf-suspend-time-start {
        description
          "Last time SPF suspended start time";
        uses OSPF-SH-TIME;
      }  // container spf-suspend-time-start

      container spf-suspend-time-stop {
        description
          "Last time SPF suspended Stop time";
        uses OSPF-SH-TIME;
      }  // container spf-suspend-time-stop

      leaf is-thread-active {
        type boolean;
        description
          "RIB thread active indicator";
      }

      leaf last-dequeue-time {
        type uint64;
        description
          "Timestamp of last dequeue of RIB work queue";
      }

      leaf first-enqueue-time {
        type uint64;
        description
          "Timestamp of first enqueue of RIB work queue";
      }

      leaf current-queue-length {
        type int32;
        description
          "Work queue length at this instance";
      }

      leaf peak-queue-length {
        type int32;
        description
          "Largest work queue length so far";
      }

      leaf total-queued-msg {
        type uint32;
        description
          "Total number of queued messages";
      }

      leaf total-dqueued-msg {
        type uint32;
        description
          "Total number of dequeued messages";
      }

      leaf rib-version {
        type uint32;
        description
          "Rib version, indicating the number of times OSPF
         has connected with RIB. The value will be
         greater than 1 if any disconnect and reconnect
         happened.";
      }

      leaf rib-packets-sent {
        type uint32;
        description
          "Total number of batches sent to RIB";
      }

      leaf rib-signals {
        type uint32;
        description
          "Number of signals for RIB thread";
      }

      leaf rib-send-errors {
        type uint32;
        description
          "Number of RIB batch send errors";
      }

      leaf rib-queue-errors {
        type uint32;
        description
          "Number of RIB batch queueing errors";
      }

      leaf rib-prefix-limit-errors {
        type uint32;
        description
          "Number of RIB batch prefix limit errors";
      }

      leaf rib-dequeue-errors {
        type uint32;
        description
          "Number of RIB batch dequeueing errors";
      }

      leaf rib-empty-batches {
        type uint32;
        description
          "Number of RIB of empty batches";
      }

      leaf rib-drops-before-sending {
        type uint32;
        description
          "Number of RIB batches dropped before sending";
      }

      leaf rib-drops-after-sending {
        type uint32;
        description
          "Number of RIB batches dropped after sending";
      }

      leaf rib-connection-drops {
        type uint32;
        description
          "Number of RIB batches dropped";
      }

      leaf rib-forward-references {
        type uint32;
        description
          "Number of forward tbl. references";
      }

      leaf priority-level {
        type string {
          length "0..40";
        }
        description
          "Priority of these batches";
      }

      leaf rib-base-clock {
        type uint64;
        description
          "Base clock stamp needed to calculate the current
         time";
      }

      leaf spf-suspend-count {
        type uint32;
        description
          "Number of times SPF suspended";
      }
    }  // grouping OSPF-SH-STATS-RIB-THREAD

    grouping OSPF-SH-STATS-WORK-QUEUES {
      description
        "OSPF SH STATS WORK QUEUES";
      container internal-work-queue {
        description
          "Router to RIB thread queue";
        uses OSPF-SH-STATS-RIB-THREAD;
      }  // container internal-work-queue

      list rib-queue {
        max-elements 8;
        description "Primary work queues";
        uses OSPF-SH-STATS-RIB-THREAD;
      }  // list rib-queue
    }  // grouping OSPF-SH-STATS-WORK-QUEUES

    grouping OSPF-EDM-RIB-NODE {
      description "OSPF EDM RIB NODE";
      leaf node-id {
        type uint32;
        description
          "node ID of the Line Card";
      }

      leaf intf-count {
        type uint16;
        description
          "Number of OSPF Interfaces";
      }

      leaf notif-count {
        type uint8;
        description "RIB notification count";
      }

      leaf ugmerge {
        type boolean;
        description
          "RIB UG merge state of the LC";
      }

      leaf node-death {
        type boolean;
        description
          "RIB node death state of LC";
      }

      leaf rib-event {
        type boolean;
        description
          "RIB event received for LC";
      }
    }  // grouping OSPF-EDM-RIB-NODE

    grouping OSPF-SH-STATS-RIB-LC {
      description "OSPF SH STATS RIB LC";
      leaf node-count {
        type uint8;
        description "Number of nodes";
      }

      list nodes {
        max-elements 64;
        description "Array of RIB Node info";
        uses OSPF-EDM-RIB-NODE;
      }  // list nodes
    }  // grouping OSPF-SH-STATS-RIB-LC

    grouping BAG-TIMESPEC {
      description "BAG TIMESPEC";
      leaf second {
        type uint32;
        description "Second";
      }

      leaf nanosecond {
        type uint32;
        description "Nanosecond";
      }
    }  // grouping BAG-TIMESPEC

    grouping OSPF-NSR-ERR-INFO-BAG {
      description "OSPF NSR ERR INFO BAG";
      container last-err-time {
        description
          "Time this error was last hit";
        uses BAG-TIMESPEC;
      }  // container last-err-time

      leaf err-count {
        type int32;
        description
          "Count this error hit during the Nsr Revision";
      }

      leaf err-info-string {
        type string;
        description "Error Information";
      }
    }  // grouping OSPF-NSR-ERR-INFO-BAG

    grouping OSPF-NSR-ERR-BLOCK-BAG {
      description "OSPF NSR ERR BLOCK BAG";
      leaf nsr-revisionversion {
        type uint32;
        description
          "Current Revision version of NSR";
      }

      leaf total-errors {
        type int32;
        description
          "Total errors for this nsr revision version";
      }

      list nsr-error-info {
        description "List of erros";
        uses OSPF-NSR-ERR-INFO-BAG;
      }  // list nsr-error-info
    }  // grouping OSPF-NSR-ERR-BLOCK-BAG

    grouping OSPF-ISSU-MILESTONE-BAG {
      description "OSPF ISSU MILESTONE BAG";
      leaf milestone-name {
        type string;
        description
          "Name of the milestone achieved";
      }

      leaf milestone-status {
        type string;
        description
          "Status of the milestone achieved";
      }
    }  // grouping OSPF-ISSU-MILESTONE-BAG

    grouping OSPF-SH-NSR-STATS-PRI {
      description
        "Statistics for a priority queue";
      leaf nsr-priority {
        type uint32;
        description "Priority value";
      }

      leaf nsr-quantum {
        type uint8;
        description
          "Number of events processed per pulse for this
         priority";
      }

      leaf nsr-remaining-quantum {
        type uint8;
        description
          "Number of events remaining to be processed";
      }

      leaf nsr-events-in-queue {
        type uint16;
        description
          "Number of events queued to the thread for this
         priority";
      }

      leaf nsr-max-events {
        type uint16;
        description
          "Max cap on the number of pending events";
      }

      leaf nsr-peak-queue-length {
        type uint16;
        description
          "Queue length of pending events peak value so far
         for this priority";
      }

      leaf nsr-events-queued {
        type uint64;
        description
          "Number of events queued on this priority since
         start/clear";
      }

      leaf nsr-enqueue-fails {
        type uint64;
        description
          "Number of enqueue failures since start/clear";
      }

      leaf nsr-events-dequeued {
        type uint64;
        description
          "Number of events dequeued on this pri since
         start/clear";
      }
    }  // grouping OSPF-SH-NSR-STATS-PRI

    grouping OSPF-SH-NSR-SCHED-STATS {
      description
        "NSR scheduling statistics";
      leaf nsr-pulse-quantum {
        type int32;
        description
          "Number of events processed per pulse";
      }

      leaf nsr-events-pending {
        type uint32;
        description
          "Total events pending processing across all
         priority buckets";
      }

      leaf nsr-events-tx {
        type uint64;
        description
          "Number of events queued to the thread";
      }

      leaf nsr-events-rx {
        type uint64;
        description
          "Number of events processed in the thread";
      }

      leaf nsr-bad-pulses-rx {
        type uint64;
        description
          "Spurious pulses received in the the thread";
      }

      leaf nsr-good-pulses-rx {
        type uint64;
        description
          "Good pulses received in the the thread";
      }

      leaf nsr-pulses-tx {
        type uint64;
        description
          "Number of pulses sent to the thread";
      }

      leaf nsr-pulses-tx-fails {
        type uint64;
        description
          "Number of pulse send fails";
      }

      list nsr-priority {
        max-elements 3;
        description
          "Statistics for each priority queue";
        uses OSPF-SH-NSR-STATS-PRI;
      }  // list nsr-priority
    }  // grouping OSPF-SH-NSR-SCHED-STATS

    grouping OSPF-SH-NSR-STATS {
      description "OSPF NSR statistics";
      container nsr-thread-scheduler-stats {
        description
          "NSR thread scheduler statistics information";
        uses OSPF-SH-NSR-SCHED-STATS;
      }  // container nsr-thread-scheduler-stats

      container nsr-router-thread-scheduler-stats {
        description
          "NSR Router thread scheduler statistics
         information";
        uses OSPF-SH-NSR-SCHED-STATS;
      }  // container nsr-router-thread-scheduler-stats

      leaf nsr-revision {
        type int32;
        description "NSR Revision number";
      }

      leaf nsr-fsm-state {
        type int32;
        description "Current state of NSR";
      }

      leaf nsr-version {
        type uint32;
        description "Version Number of NSR";
      }

      leaf nsr-node-id {
        type uint32;
        description "Node ID";
      }

      leaf nsr-peer-version {
        type uint32;
        description "Peer version of NSR";
      }

      leaf nsr-peer-node-id {
        type uint32;
        description "Node ID of the peer";
      }

      leaf nsr-peer-end-point-length {
        type uint32;
        description
          "Length of the endpoint retrieved from peer";
      }

      leaf nsr-peer-end-point-version {
        type uint32;
        description
          "Version of the endpoint retrieved from peer";
      }

      leaf nsr-local-end-point-length {
        type uint32;
        description
          "Length of local endpoint";
      }

      leaf nsr-local-end-point-version {
        type uint32;
        description
          "Version of local endpoint";
      }

      leaf nsr-fabric-mtu {
        type uint32;
        description "MTU of Fabric";
      }

      leaf nsr-neighbor-qad-queue-id {
        type uint32;
        description
          "QAD Queue ID for Neighbor information";
      }

      leaf nsr-lsa-qad-queue-id {
        type uint32;
        description
          "QAD Queue ID for LSA information";
      }

      leaf nsr-neighbor-qad-meta-data-count {
        type uint32;
        description
          "QAD metadata Information for Neighbor";
      }

      leaf nsr-lsa-qad-meta-data-count {
        type uint32;
        description
          "QAD metadata Information for LSA";
      }

      leaf nsr-neighbor-init-sync-pend-count {
        type int32;
        description
          "Pending message count for Initial neighbor
         synchronization";
      }

      leaf nsr-lsa-init-sync-pend-count {
        type int32;
        description
          "Pending message count for Initial lsa
         synchronization";
      }

      leaf nsr-neighbor-seq-no {
        type uint32;
        description
          "Sequence number used for neighbor
         synchronization";
      }

      leaf nsr-interface-seq-no {
        type uint32;
        description
          "Sequence number used for interface
         synchronization";
      }

      leaf nsr-timerquantum {
        type int32;
        description
          "Number of expired timers to process per event
         manager call";
      }

      leaf nsr-peer-end-point-handle {
        type uint64;
        description "Remote endpoint handle";
      }

      leaf nsr-local-endpoint-handle {
        type uint64;
        description
          "Handle/id of local endpoint";
      }

      leaf nsr-connect-attempts {
        type uint64;
        description
          "Count of LWN connection attempts";
      }

      leaf nsr-connect-failures {
        type uint64;
        description
          "Count of LWN connection failures";
      }

      leaf nsr-open-event-count {
        type uint64;
        description
          "Count of LWN connection open events";
      }

      leaf nsr-close-event-count {
        type uint64;
        description
          "Count of LWN connection close events";
      }

      leaf nsr-error-event-count {
        type uint64;
        description
          "Count of LWN connection error events";
      }

      leaf nsr-peer-end-points {
        type yang:hex-string;
        description
          "Array of remote endpoints";
      }

      leaf nsr-local-end-points {
        type yang:hex-string;
        description
          "Array of local endpoints";
      }

      list nsr-fsm-flag {
        description
          "Nsr Fsm Flags information";
        leaf entry {
          type Ospf-string-array;
          description
            "Nsr Fsm Flags information";
        }
      }  // list nsr-fsm-flag

      list nsr-fsm-running-timer {
        description "Nsr Fsm Running Timers";
        leaf entry {
          type Ospf-string-array;
          description
            "Nsr Fsm Running Timers";
        }
      }  // list nsr-fsm-running-timer

      list nsr-issu-milestone {
        description
          "Nsr Issu Milestones information";
        uses OSPF-ISSU-MILESTONE-BAG;
      }  // list nsr-issu-milestone

      list nsr-err-history {
        description
          "Nsr Error History List information";
        uses OSPF-NSR-ERR-BLOCK-BAG;
      }  // list nsr-err-history
    }  // grouping OSPF-SH-NSR-STATS

    grouping OSPF-SH-RIB-BATCH {
      description
        "RIB interaction statistics for a priority level";
      leaf batches-sent {
        type uint32;
        description
          "Number of batches sent to RIB ";
      }

      leaf routes-sent {
        type uint32;
        description
          "Number of routes updates sent to RIB ";
      }

      leaf routes-pending {
        type uint32;
        description
          "Number of routes waiting to be sent to RIB";
      }

      leaf max-routes {
        type uint32;
        description
          "Max number of routes in a batch";
      }

      leaf paths-sent {
        type uint32;
        description
          "Number of paths (add+delete) sent to RIB";
      }

      leaf paths-pending {
        type uint32;
        description
          "Number of paths waiting to be sent to RIB";
      }

      leaf paths-added {
        type uint32;
        description
          "Number of paths added (pending+sent) to RIB ";
      }

      leaf path-add-errors {
        type uint32;
        description
          "Number of paths add errors";
      }

      leaf path-deletions {
        type uint32;
        description
          "Number of paths deletions (pending+sent) to RIB";
      }

      leaf path-deletion-errors {
        type uint32;
        description
          "Number of paths deletion errors";
      }

      leaf lfas-pending {
        type uint32;
        description
          "Number of LFAs waiting to be sent to RIB";
      }

      leaf lfas-added {
        type uint32;
        description
          "Number of LFAs added to the RIB";
      }

      leaf lfa-deletions {
        type uint32;
        description
          "Number of LFAs deleted from RIB";
      }

      leaf lfas-sent {
        type uint32;
        description
          "Number of LFAs sent to the RIB";
      }

      leaf priority-level {
        type string {
          length "0..40";
        }
        description
          "Priority Level Name string";
      }
    }  // grouping OSPF-SH-RIB-BATCH

    grouping OSPF-SH-RIB-BATCH-PRIORITY-QUEUES {
      description
        "Statistics on RIB interaction";
      list priority-batch {
        max-elements 8;
        description
          "RIB interaction statistics for various priority
         levels";
        uses OSPF-SH-RIB-BATCH;
      }  // list priority-batch
    }  // grouping OSPF-SH-RIB-BATCH-PRIORITY-QUEUES

    grouping OSPF-EDM-AREA-SUMM {
      description
        "OSPF SPF statistics of an Area";
      leaf area-id {
        type uint32;
        description "Area ID in OSPF";
      }

      leaf spf-count {
        type uint32;
        description
          "Count of SPFs in this area";
      }
    }  // grouping OSPF-EDM-AREA-SUMM

    grouping OSPF-HEADER-INFO {
      description
        "OSPF SPF information header";
      leaf router-id {
        type inet:ipv4-address;
        description "OSPF router identifier";
      }

      leaf spf-count {
        type uint32;
        description
          "Count of SPFs in this area";
      }

      list area-summ {
        description
          "SPF details of the area";
        uses OSPF-EDM-AREA-SUMM;
      }  // list area-summ
    }  // grouping OSPF-HEADER-INFO

    grouping OSPF-EDM-SPF-AREA-STATS {
      description
        "SPF statistics of the Area";
      container spf-time {
        description
          "Time taken for various stages of SPF";
        uses OSPF-SPF-TIME;
      }  // container spf-time

      leaf area-id {
        type uint32;
        description "OSPF area id";
      }

      list lsa-type-count {
        max-elements 7;
        description
          "Array of Count of LSA changes indexed by LSA
         
         Type";
        leaf entry {
          type uint32;
          description
            "Array of Count of LSA changes indexed by LSA
           
           Type";
        }
      }  // list lsa-type-count
    }  // grouping OSPF-EDM-SPF-AREA-STATS

    grouping OSPF-LSA-CHANGE {
      description
        "Details of LSA change that triggered the SPF";
      leaf area-id {
        type uint32;
        description
          "Area where LSA got changed";
      }

      leaf advertising-router {
        type inet:ipv4-address;
        description
          "Advertising Router of the changed LSA";
      }

      leaf ls-id {
        type inet:ipv4-address;
        description
          "LS ID of the changed LSA";
      }

      leaf ls-type {
        type uint8;
        description
          "Type of the changed LSA";
      }

      leaf is-flush {
        type boolean;
        description
          "Whether it is a flushed LSA";
      }
    }  // grouping OSPF-LSA-CHANGE

    grouping OSPF-SPF-TIME {
      description
        "Time taken for various stages of SPF";
      leaf time-taken-dijkstra {
        type uint32;
        description
          "Time taken for executing  Dijkstra Algorithm";
      }

      leaf time-taken-intra-prefix {
        type uint32;
        description
          "Time taken for Intra Area Prefix calculations";
      }

      leaf time-taken-intra-prefix-deletion {
        type uint32;
        description
          "Time taken for Intra Area Prefix deletions";
      }

      leaf time-taken-inter-prefix {
        type uint32;
        description
          "Time taken for Inter Area Prefix calculations";
      }

      leaf time-taken-inter-prefix-deletion {
        type uint32;
        description
          "Time taken for Inter Area Prefix deletions";
      }

      leaf time-taken-external-prefix {
        type uint32;
        description
          "Time taken for Type 5/7 Prefix calculations";
      }

      leaf time-taken-external-prefix-deletion {
        type uint32;
        description
          "Time taken for Type 5/7 Prefix deletions";
      }
    }  // grouping OSPF-SPF-TIME

    grouping OSPF-RUNTIME-STATS {
      description
        "SPF runtime statistics of OSPF";
      container gbl-spf-time {
        description "Time taken for SPF";
        uses OSPF-SPF-TIME;
      }  // container gbl-spf-time

      leaf spf-start-time {
        type uint32;
        description "Time when SPF started";
      }

      leaf lsa-change-count {
        type int16;
        description "Count of changed LSAs";
      }

      leaf spf-number {
        type uint8;
        description "SPF ID";
      }

      list lsa-info {
        max-elements 5;
        description
          "Details of changed LSAs";
        uses OSPF-LSA-CHANGE;
      }  // list lsa-info

      list area-stat {
        description
          "SPF Statistics of this area";
        uses OSPF-EDM-SPF-AREA-STATS;
      }  // list area-stat
    }  // grouping OSPF-RUNTIME-STATS

    grouping OSPF-SH-STAT-PARTIAL {
      description "Partial SPF statistics";
      container start-time {
        description
          "Time elapsed since last Partial SPF run";
        uses OSPF-SH-TIME;
      }  // container start-time

      container duration {
        description
          "Time taken for the this Partial SPF calculation";
        uses OSPF-SH-TIME;
      }  // container duration

      leaf advertising-router-id {
        type uint32;
        description
          "Advertising Router ID of the changed LSA that
         triggered this partial SPF";
      }

      leaf destination-count {
        type uint32;
        description
          "Number of LSAs changed by this advertising
         router that is being handled in this partial SPF";
      }

      leaf destination-address {
        type uint32;
        description
          "Route prefix changed in this partial SPF";
      }
    }  // grouping OSPF-SH-STAT-PARTIAL

    grouping OSPF-SH-STAT-INTRA {
      description
        "Intra-area SPF statistics";
      container start-time {
        description
          "Time elapsed since last Intra SPF run";
        uses OSPF-SH-TIME;
      }  // container start-time

      container duration {
        description
          "Time taken for the this Intra SPF calculation";
        uses OSPF-SH-TIME;
      }  // container duration

      leaf area-id {
        type string;
        description "Area ID in OSPF";
      }

      leaf change-flags {
        type uint16;
        description
          "Flags indicating changes that triggered this SPF";
      }
    }  // grouping OSPF-SH-STAT-INTRA

    grouping OSPF-SH-STATS-SPF {
      description "SPF statistics of OSPF";
      container spf-header {
        description "SPF Header information";
        uses OSPF-HEADER-INFO;
      }  // container spf-header

      list runtime {
        description
          "Time taken for the Intra-area SPF run";
        uses OSPF-SH-STAT-INTRA;
      }  // list runtime

      list summary-runtime {
        description
          "Time taken for the summary calculation";
        uses OSPF-SH-STAT-PARTIAL;
      }  // list summary-runtime

      list external-runtime {
        description
          "Time taken for the external calculation";
        uses OSPF-SH-STAT-PARTIAL;
      }  // list external-runtime

      list total-runtime {
        description
          "Time taken for entire route calculation";
        uses OSPF-RUNTIME-STATS;
      }  // list total-runtime
    }  // grouping OSPF-SH-STATS-SPF
  }  // submodule Cisco-IOS-XR-ipv4-ospf-oper-sub3