submodule Cisco-IOS-XR-ipv6-ospfv3-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-ipv6-ospfv3-oper {
        prefix
          Cisco-IOS-XR-ipv6-ospfv3-oper;
    }

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

    organization "Cisco Systems, Inc.";

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

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

    revision "2020-04-29" {
      description
        "Added mtu and Bandwidth to show command";
    }

    revision "2020-02-04" {
      description
        "Modified for Conditional Advertising";
    }

    revision "2019-07-28" {
      description
        "Added datalist operation for container fast-reroute topology";
    }

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

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

    revision "2018-06-15" {
      description
        "Added Aggregate statistics under summary container";
    }

    revision "2017-10-30" {
      description
        "Added link information in grace LSA.";
    }

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

    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-nsr-sched-pri {
      type enumeration {
        enum "ospf-nsr-stats-sched-pri-hi" {
          value 0;
          description
            "ospf nsr stats sched pri hi";
        }
        enum "ospf-nsr-stats-sched-pri-med" {
          value 1;
          description
            "ospf nsr stats sched pri med";
        }
        enum "ospf-nsr-stats-sched-pri-low" {
          value 2;
          description
            "ospf nsr stats sched pri low";
        }
        enum "ospf-nsr-stats-sched-pri-max" {
          value 3;
          description
            "ospf nsr stats sched pri max";
        }
      }
      description "Ospf nsr sched pri";
    }

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

    typedef Ospfv3-graceful-shutdown-state {
      type enumeration {
        enum "init" {
          value 0;
          description "Init";
        }
        enum "normal" {
          value 1;
          description "Normal";
        }
        enum "flushing" {
          value 2;
          description "Flushing";
        }
        enum "empty-hellos" {
          value 3;
          description "Empty Hellos";
        }
        enum "quiet" {
          value 4;
          description "Quiet";
        }
      }
      description "Graceful Shutdown state";
    }

    typedef Ipfrr-tbrkr {
      type enumeration {
        enum "downstream" {
          value 0;
          description "Downsteram";
        }
        enum "line-card-disjoint" {
          value 1;
          description "LC Disjoint";
        }
        enum "backup-metric" {
          value 2;
          description "Backup metric";
        }
        enum "node-protect" {
          value 3;
          description "Node protection";
        }
        enum "primary-path" {
          value 4;
          description "Primary path";
        }
        enum "secondary-path" {
          value 5;
          description "Secondary path";
        }
        enum "srlg-disjoint" {
          value 6;
          description "SRLG disjoint";
        }
        enum "tunnel" {
          value 7;
          description "Tunnel";
        }
      }
      description "FRR Tiebreakers";
    }

    typedef Stub-router-abr-off-reason {
      type enumeration {
        enum "init-delay" {
          value 2;
          description
            "Initial delay when stub router mode is
           activated";
        }
        enum "no-neighbor" {
          value 3;
          description "No neighbor present";
        }
        enum "no-full-neighbor" {
          value 4;
          description
            "No neighbor in FULL state present";
        }
        enum "new-neighbor" {
          value 5;
          description
            "A new neighbor discovered less than 60 seconds
           ago";
        }
        enum "full-neighbor" {
          value 6;
          description
            "A neighbor transitioned to FULL state less than
           60 seconds ago";
        }
      }
      description
        "Reason to exiting stub router mode";
    }

    typedef Stub-router-exit-reason {
      type enumeration {
        enum "none" {
          value 0;
          description "No reason";
        }
        enum "bgp" {
          value 1;
          description "BGP has converged";
        }
        enum "timer" {
          value 2;
          description
            "Stub Router timer has expired";
        }
        enum "configuration" {
          value 3;
          description
            "Configuration has changed";
        }
        enum "cleared" {
          value 4;
          description
            "Process has been cleared";
        }
        enum "override" {
          value 5;
          description "Preempted by always";
        }
      }
      description
        "Reason to exiting stub router mode";
    }

    typedef Stub-router-trigger {
      type enumeration {
        enum "on-proc-migration" {
          value 0;
          description "Process migration";
        }
        enum "on-proc-restart" {
          value 1;
          description "Process restart";
        }
        enum "on-switchover" {
          value 2;
          description "RP switchover";
        }
        enum "on-startup" {
          value 3;
          description "Router startup";
        }
        enum "always" {
          value 4;
          description "Always on";
        }
        enum "none" {
          value 5;
          description "No trigger";
        }
      }
      description
        "Trigger for entering stub router mode";
    }

    typedef Stub-router-mode {
      type enumeration {
        enum "rbit" {
          value 0;
          description
            "Stub Router mode r-bit";
        }
        enum "v6bit" {
          value 1;
          description
            "Stub Router mode v6-bit";
        }
        enum "max-metric" {
          value 2;
          description
            "Stub Router mode max-metric";
        }
        enum "none" {
          value 3;
          description
            "Stub Router not configured";
        }
      }
      description "Stub Router mode";
    }

    typedef Ospfv3-neighbor-state {
      type enumeration {
        enum "neigbhor-down" {
          value 0;
          description "Down";
        }
        enum "attempt" {
          value 1;
          description "Attempting";
        }
        enum "init" {
          value 2;
          description "Initializing";
        }
        enum "two-way" {
          value 3;
          description "2 Way";
        }
        enum "exstart" {
          value 4;
          description "Exstart";
        }
        enum "exchange" {
          value 5;
          description "Exchange";
        }
        enum "loading" {
          value 6;
          description "Loading";
        }
        enum "full" {
          value 7;
          description "Full";
        }
        enum "sc-virtual" {
          value 8;
          description "SCVirtual";
        }
      }
      description "OSPFv3 neighbor states";
    }

    typedef Ospfv3-interface {
      type enumeration {
        enum "none" {
          value 0;
          description "None";
        }
        enum "broadcast" {
          value 1;
          description "Broadcast";
        }
        enum "non-broadcast" {
          value 2;
          description "Non broadcast";
        }
        enum "point-to-point" {
          value 3;
          description "Point To Point";
        }
        enum "point-to-multipoint" {
          value 4;
          description "Point To Multipoint";
        }
        enum
          "point-to-multipoint-non-broadcast" {
          value 5;
          description
            "Point-To-Multipoint Non broadcast";
        }
        enum "virtual-link" {
          value 6;
          description "Virtual link";
        }
        enum "loopback-interface" {
          value 7;
          description "Loopback";
        }
        enum "mpls-traffic-engineering" {
          value 8;
          description
            "MPLS traffic engineering";
        }
        enum "sham-link" {
          value 9;
          description "Sham link";
        }
      }
      description
        "OSPFv3 neighbor interface types";
    }

    typedef Im-state-enum {
      type enumeration {
        enum "im-state-not-ready" {
          value 0;
          description "im state not ready";
        }
        enum "im-state-admin-down" {
          value 1;
          description "im state admin down";
        }
        enum "im-state-down" {
          value 2;
          description "im state down";
        }
        enum "im-state-up" {
          value 3;
          description "im state up";
        }
        enum "im-state-shutdown" {
          value 4;
          description "im state shutdown";
        }
        enum "im-state-err-disable" {
          value 5;
          description "im state err disable";
        }
        enum "im-state-down-immediate" {
          value 6;
          description
            "im state down immediate";
        }
        enum "im-state-down-immediate-admin" {
          value 7;
          description
            "im state down immediate admin";
        }
        enum "im-state-down-graceful" {
          value 8;
          description
            "im state down graceful";
        }
        enum "im-state-begin-shutdown" {
          value 9;
          description
            "im state begin shutdown";
        }
        enum "im-state-end-shutdown" {
          value 10;
          description
            "im state end shutdown";
        }
        enum "im-state-begin-error-disable" {
          value 11;
          description
            "im state begin error disable";
        }
        enum "im-state-end-error-disable" {
          value 12;
          description
            "im state end error disable";
        }
        enum "im-state-begin-down-graceful" {
          value 13;
          description
            "im state begin down graceful";
        }
        enum "im-state-reset" {
          value 14;
          description "im state reset";
        }
        enum "im-state-operational" {
          value 15;
          description "im state operational";
        }
        enum "im-state-not-operational" {
          value 16;
          description
            "im state not operational";
        }
        enum "im-state-unknown" {
          value 17;
          description "im state unknown";
        }
        enum "im-state-last" {
          value 18;
          description "im state last";
        }
      }
      description "Im state enum";
    }

    typedef Ospfv3-interface-state {
      type enumeration {
        enum "down" {
          value 0;
          description "Down";
        }
        enum "loopback" {
          value 1;
          description "Loopback";
        }
        enum "waiting" {
          value 2;
          description "Waiting";
        }
        enum "point-to-multipoint" {
          value 3;
          description "Point To Multipoint";
        }
        enum "point-to-point" {
          value 4;
          description "Point To Point";
        }
        enum "designated-router" {
          value 5;
          description "Designated router";
        }
        enum "backup-designated-router" {
          value 6;
          description
            "Backup designated router";
        }
        enum "other-designated-router" {
          value 7;
          description
            "Other designated router";
        }
      }
      description "OSPFv3 interface states";
    }

    typedef Ospfv3-graceful-restart-reason {
      type enumeration {
        enum "grace-reason-unknown" {
          value 0;
          description "Grace reason unknown";
        }
        enum "grace-reason-software-restart" {
          value 1;
          description
            "Grace reason software restart";
        }
        enum "grace-reason-software-upgrade" {
          value 2;
          description
            "Software reload/upgrade, RFC 3623";
        }
        enum "grace-reason-switchover" {
          value 3;
          description
            "Switch to redundant control processor";
        }
      }
      description
        "Reason for router restart";
    }

    typedef Ospfv3-lsa1 {
      type enumeration {
        enum "link" {
          value 8;
          description "Link LSA";
        }
        enum "grace" {
          value 11;
          description "Grace LSA";
        }
        enum "router" {
          value 8193;
          description "Router LSA";
        }
        enum "network" {
          value 8194;
          description "Network LSA";
        }
        enum "inter-area-prefix" {
          value 8195;
          description
            "Inter area prefix LSA";
        }
        enum "inter-area-router" {
          value 8196;
          description
            "Inter area router LSA";
        }
        enum "mospf" {
          value 8198;
          description "MOSPF LSA";
        }
        enum "type7-external" {
          value 8199;
          description "Type-7 External LSA";
        }
        enum "lsa-prefix" {
          value 8201;
          description "Prefix LSA";
        }
        enum "as-external" {
          value 16389;
          description "AS external LSA";
        }
        enum "unknown-link" {
          value 32768;
          description "Unknown link LSA";
        }
        enum "unknown-area" {
          value 40960;
          description "Unknown area LSA";
        }
        enum "unknown-as" {
          value 49152;
          description "Unknown AS LSA";
        }
        enum "unknown-type" {
          value 57344;
          description "Unknown type LSA";
        }
      }
      description "OSPFv3 LSA types";
    }

    typedef Prefix-priority {
      type enumeration {
        enum "critical" {
          value 0;
          description "Critical priority";
        }
        enum "high" {
          value 1;
          description "High priority";
        }
        enum "medium" {
          value 2;
          description "Medium priority";
        }
        enum "low" {
          value 3;
          description "Low priority";
        }
      }
      description "Prefix priority";
    }

    typedef Ospfv3-link {
      type enumeration {
        enum "link-router" {
          value 1;
          description "Router link";
        }
        enum "link-trans-net" {
          value 2;
          description "Transit network link";
        }
        enum "link-virtual-link" {
          value 4;
          description "Virutal link";
        }
      }
      description "OSPFV3 Link type";
    }

    typedef Ospf-lsa-sync-state {
      type enumeration {
        enum "none" {
          value 0;
          description "State not set";
        }
        enum "out-of-sync" {
          value 1;
          description
            "LSA out of sync with active";
        }
        enum "in-sync" {
          value 2;
          description
            "LSA in sync with active";
        }
        enum "nsr-ack-pending" {
          value 3;
          description
            "NSR ack pending for LSA sync";
        }
      }
      description
        "LSA synchronization states";
    }

    typedef Ospfv3-lsa-info-types {
      type enumeration {
        enum "mgmt-lsa-lsasum-type" {
          value 0;
          description
            "Summary information of LSAs";
        }
        enum "mgmt-lsa-link-type" {
          value 8;
          description "Link LSA";
        }
        enum "mgmt-lsa-gr-type" {
          value 11;
          description "Grace LSA";
        }
        enum "mgmt-lsa-rtr-type" {
          value 8193;
          description "Router LSA";
        }
        enum "mgmt-lsa-net-type" {
          value 8194;
          description "Network LSA";
        }
        enum "mgmt-lsa-iapfx-type" {
          value 8195;
          description
            "Inter Area Prefix Summary LSA";
        }
        enum "mgmt-lsa-iartr-type" {
          value 8196;
          description
            "Inter Area Router Summay LSA";
        }
        enum "mgmt-lsa-nssaext-type" {
          value 8199;
          description "NSSA external LSA";
        }
        enum "mgmt-lsa-prefix-type" {
          value 8201;
          description
            "Intra Area Prefix LSA";
        }
        enum "mgmt-lsa-ext-type" {
          value 16389;
          description "Type 5 External LSA";
        }
        enum "mgmt-lsa-unk-link-type" {
          value 32768;
          description
            "Opaque Link scope LSA";
        }
        enum "mgmt-lsa-unk-area-type" {
          value 40960;
          description
            "Opaque Area scope LSA";
        }
        enum "mgmt-lsa-unk-as-type" {
          value 49152;
          description "Opaque AS scope LSA";
        }
        enum "mgmt-lsa-unk-type" {
          value 57344;
          description
            "Opaque Reserved scope LSA";
        }
      }
      description "OSPFv3 LSA format types";
    }

    typedef Ospfv3-area-range-status {
      type enumeration {
        enum "advertise" {
          value 1;
          description "Advertise this range";
        }
        enum "do-not-advertise" {
          value 2;
          description
            "Do not advertise this range";
        }
      }
      description "Ospfv3 area range status";
    }

    typedef Ospfv3-border-route {
      type enumeration {
        enum "abr" {
          value 1;
          description "Area border router";
        }
        enum "asbr" {
          value 2;
          description
            "Area system boundary router";
        }
        enum "abr-asbr" {
          value 3;
          description
            "Area border router and area system boundary
           router";
        }
      }
      description
        "OSPFv3 border route destination types";
    }

    typedef Ospfv3-default-metric {
      type enumeration {
        enum "type-none" {
          value 0;
          description
            "OSPFv3 default metric type None ";
        }
        enum "type1" {
          value 1;
          description
            "OSPFv3 default metric type 1 ";
        }
        enum "type2" {
          value 2;
          description
            "OSPFv3 default metric type 2 ";
        }
      }
      description
        "OSPFv3 default metric types ";
    }

    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 ncd-pri {
        max-elements 2;
        description
          "NCD statistics for various priorities";
        uses NSR-PL-CLIENT-STATS-TYPE;
      }  // list ncd-pri
    }  // grouping OSPF-SH-NCD-STATS

    grouping OSPFV3-EDM-RTHREAD-QUEUE-STATS {
      description
        "OSPFv3 RIB thread queue statistics";
      leaf wq-eqtime {
        type uint64;
        description "Head Entry Enqueue";
      }

      leaf wq-dqtime {
        type uint64;
        description "Last Entry Dequeue";
      }

      leaf wq-first-eqtime {
        type uint64;
        description "First Entry Enqueue";
      }

      leaf wq-len-cur {
        type int32;
        description
          "Current Work Queue Length";
      }

      leaf wq-len-max {
        type int32;
        description
          "Largest Work Queue Length";
      }

      leaf wq-total-enqueued {
        type uint32;
        description "Total Entries Enqueued";
      }

      leaf wq-total-dequeued {
        type uint32;
        description "Total Entries Dequeued";
      }

      leaf wq-eneueue-errs {
        type uint32;
        description "Enqueue Errors";
      }

      leaf wq-dequeue-errs {
        type uint32;
        description "Dequeue Errors";
      }

      leaf wq-max-latency {
        type uint64;
        description
          "Max Time Entry Was In Q";
      }

      leaf wq-sum-latency {
        type uint64;
        description
          "Sum Latencies To Calc Average";
      }
    }  // grouping OSPFV3-EDM-RTHREAD-QUEUE-STATS

    grouping OSPFV3-EDM-RTHREAD-STATS {
      description
        "OSPFv3 RIB thread statistics";
      container thread-q {
        description "Inter Thread Queue";
        uses OSPFV3-EDM-RTHREAD-QUEUE-STATS;
      }  // container thread-q

      container rib-base-time {
        description "Current time stamp";
        uses OSPFV3-EDM-TIME;
      }  // container rib-base-time

      leaf wq-thread-active {
        type boolean;
        description
          "RIB Thread Active Indicator";
      }

      leaf wq-signals {
        type uint32;
        description
          "Signals sent to RIB Thread";
      }

      leaf rib-base-clock {
        type uint64;
        description
          "Rib Base Clock value to calculate current time
         from the timestamp";
      }

      leaf rib-batch-sent {
        type uint32;
        description
          "No. of Rib batches sent";
      }

      leaf rib-batch-purged {
        type uint32;
        description
          "No. of Rib batches purged";
      }

      leaf rib-drop-version {
        type uint32;
        description
          "No. of Rib batches dropped due to version
         mismatch";
      }

      leaf rib-drop-conn {
        type uint32;
        description
          "No. of Rib batches dropped due to connection
         issues";
      }

      leaf rib-batch-ok {
        type uint32;
        description
          "No. of Rib batches where all routes were
         installed as active";
      }

      leaf rib-batch-backup {
        type uint32;
        description
          "No. of Rib batches where some routes were
         installed as backup";
      }

      leaf rib-batch-limit {
        type uint32;
        description
          "No. of Rib batches that failed because Batch
         limit reached";
      }

      leaf rib-batch-no-table {
        type uint32;
        description
          "No. of Rib batches that failed because table is
         not created";
      }

      leaf rib-batch-some-err {
        type uint32;
        description
          "No. of Rib batches that failed to install
         partially, where some routes in the batch were
         installed, others failed";
      }

      leaf rib-batch-err {
        type uint32;
        description
          "No. of Rib batches that failed install entirely";
      }

      leaf rib-route-limit {
        type uint32;
        description
          "No. of routes failed to install due to Route
         table limit";
      }

      leaf rib-route-some-err {
        type uint32;
        description
          "No. of routes failed to install partially, where
         some of the paths in the route got installed,
         but others failed";
      }

      leaf rib-route-err {
        type uint32;
        description
          "No. of routes that failed install entirely";
      }

      leaf rib-path-limit {
        type uint32;
        description
          "No. of routes that failed install due to path
         limit";
      }

      leaf rib-path-err {
        type uint32;
        description
          "No. of routes that failed install due to errors
         other than path limit";
      }

      leaf rib-max-latency {
        type uint64;
        description
          "Max time entry was in queue";
      }

      leaf rib-sum-latency {
        type uint64;
        description
          "Sum of latencies to calculate average latency";
      }

      list holdq {
        max-elements 4;
        description "Rib thread Hold Queues";
        uses OSPFV3-EDM-RTHREAD-QUEUE-STATS;
      }  // list holdq
    }  // grouping OSPFV3-EDM-RTHREAD-STATS

    grouping OSPFV3-NSR-ERR-INFO-BAG {
      description "OSPFV3 NSR ERR INFO BAG";
      container last-err-time {
        description
          "Time this error was last hit";
        uses OSPFV3-EDM-TIME;
      }  // 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 OSPFV3-NSR-ERR-INFO-BAG

    grouping OSPFV3-NSR-ERR-BLOCK-BAG {
      description "OSPFV3 NSR ERR BLOCK BAG";
      leaf nsr-revisionversion {
        type uint32;
        description
          "Revision version number for NSR";
      }

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

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

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

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

    grouping OSPF-SH-NSR-STATS-PRI {
      description "OSPF SH NSR STATS PRI";
      leaf nsr-sched-pri {
        type Ospf-nsr-sched-pri;
        description "Priority Type";
      }

      leaf nsr-sched-quant {
        type uint8;
        description "Priority Queue";
      }

      leaf nsr-sched-remain-quant {
        type uint8;
        description "Remaining quantum";
      }

      leaf nsr-sched-evs-in-q {
        type uint16;
        description "Events pending";
      }

      leaf nsr-sched-max-evs {
        type uint16;
        description "Max Queued";
      }

      leaf nsr-sched-peak-q-len {
        type uint16;
        description "Peak queue length";
      }

      leaf nsr-sched-evs-qd {
        type uint64;
        description "Events queued";
      }

      leaf nsr-sched-enq-fails {
        type uint64;
        description "Event enqueue fails";
      }

      leaf nsr-sched-evs-deqd {
        type uint64;
        description "Events dequeued";
      }
    }  // grouping OSPF-SH-NSR-STATS-PRI

    grouping OSPF-SH-NSR-SCHED-STATS {
      description "OSPF SH NSR SCHED STATS";
      leaf nsr-pulse-quant {
        type int32;
        description
          "Events processed per pulse";
      }

      leaf nsr-events-in-q {
        type uint32;
        description "Events pending";
      }

      leaf nsr-events-tx {
        type uint64;
        description
          "Events to Router thread";
      }

      leaf nsr-events-rx {
        type uint64;
        description "Events processed";
      }

      leaf nsr-bad-pulses-rx {
        type uint64;
        description "Bad pulses received";
      }

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

      leaf nsr-pulses-tx {
        type uint64;
        description
          "Pulses to Router thread";
      }

      leaf nsr-pulse-tx-fails {
        type uint64;
        description "Pulse send failures";
      }

      list nsr-pri {
        max-elements 3;
        description
          "NSR priority statistics";
        uses OSPF-SH-NSR-STATS-PRI;
      }  // list nsr-pri
    }  // grouping OSPF-SH-NSR-SCHED-STATS

    grouping OSPFV3-EDM-NSR-STATS {
      description "OSPFV3 EDM NSR STATS";
      container nsr-thd-stats {
        description
          "NSR thread scheduler stats";
        uses OSPF-SH-NSR-SCHED-STATS;
      }  // container nsr-thd-stats

      container nsr-rtr-thd-sched {
        description
          "Rtr thread NSR pulse handler stats";
        uses OSPF-SH-NSR-SCHED-STATS;
      }  // container nsr-rtr-thd-sched

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

      leaf nsr-fsm-state {
        type int32;
        description "FSM state";
      }

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

      leaf nsr-node-id {
        type uint32;
        description "My nodeid";
      }

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

      leaf nsr-peer-node-id {
        type uint32;
        description "Partner NodeID";
      }

      leaf nsr-peer-ep-length {
        type uint32;
        description "Peer Endpoint Length";
      }

      leaf nsr-peer-ep-ver {
        type uint32;
        description "Peer Endpoint Version";
      }

      leaf nsr-local-ep-length {
        type uint32;
        description "Local Endpoint Length";
      }

      leaf nsr-local-ep-ver {
        type uint32;
        description "Local Endpoint Version";
      }

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

      leaf nsr-nbr-qad-qid {
        type uint32;
        description "NBR QAD queue id";
      }

      leaf nsr-lsa-qad-qid {
        type uint32;
        description "LSA QAD queue id";
      }

      leaf nsr-nbr-qad-mdata-count {
        type uint32;
        description "NBR QAD pending msg";
      }

      leaf nsr-lsa-qad-mdata-count {
        type uint32;
        description "LSA QAD pending msgs";
      }

      leaf nsr-nbr-init-sync-pend-count {
        type int32;
        description
          "Pending init-sync NBR msgs";
      }

      leaf nsr-lsa-init-sync-pend-count {
        type int32;
        description
          "Pending init-sync LSA msgs";
      }

      leaf nsr-nbr-seq-no {
        type uint32;
        description
          "Neighbor TLV sequence no";
      }

      leaf nsr-intf-seq-no {
        type uint32;
        description
          "Interface TLV sequence no";
      }

      leaf nsr-tmr-quant {
        type int32;
        description
          "Timers processed per pulse";
      }

      leaf nsr-peer-hdl {
        type uint64;
        description "Peer DS Handle";
      }

      leaf nsr-local-hdl {
        type uint64;
        description "Local DS Handle";
      }

      leaf nsr-conn-to-active-attempts {
        type uint64;
        description
          "No. of Attempts to connect to active";
      }

      leaf nsr-conn-to-active-fails {
        type uint64;
        description
          "No. of Failures to connect to active";
      }

      leaf nsr-conn-to-active-opens {
        type uint64;
        description
          "No. of active connections opened";
      }

      leaf nsr-conn-to-active-closes {
        type uint64;
        description
          "No. of active connections closed";
      }

      leaf nsr-conn-to-active-errors {
        type uint64;
        description
          "No. of connections errors";
      }

      leaf nsr-peer-ep {
        type yang:hex-string;
        description "Peer Endpoint";
      }

      leaf nsr-local-ep {
        type yang:hex-string;
        description "Local Endpoint";
      }

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

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

      list nsr-issu-milestone {
        description "Milestones of NSR ISSU";
        uses OSPFV3-ISSU-MILESTONE-BAG;
      }  // list nsr-issu-milestone

      list nsr-err-history {
        description
          "Error History List of NSR";
        uses OSPFV3-NSR-ERR-BLOCK-BAG;
      }  // list nsr-err-history
    }  // grouping OSPFV3-EDM-NSR-STATS

    grouping OSPF-SH-IPFRR-TOPO-ENTRY {
      description
        "OSPF_IPFRR Topology Entry";
      leaf node-id {
        type inet:ipv4-address;
        description "IPFRR Topology Node ID";
      }

      leaf lsaid {
        type uint32;
        description "IPFRR Topology LSA ID";
      }

      leaf distance {
        type uint32;
        description
          "IPFRR Topology Distance";
      }

      leaf type4 {
        type boolean;
        description
          "IPFRR Topoogy Type-4 entry";
      }

      leaf revision {
        type uint32;
        description
          "IPFRR Topology Revision";
      }

      leaf neighbor-sourced {
        type boolean;
        description
          "IPFRR Topology Neighbor Sourced";
      }

      leaf dr {
        type boolean;
        description
          "IPFRR Topology DR entry";
      }
    }  // grouping OSPF-SH-IPFRR-TOPO-ENTRY

    grouping OSPFV3-SH-IPFRR-TOPO {
      description
        "OSPF IPFRR Topology Information";
      leaf ipfrr-topo-area-id {
        type string {
          length "0..16";
        }
        description
          "Area ID string in decimal or dotted decimal
         format";
      }

      leaf ipfrr-local-router-id {
        type inet:ipv4-address;
        description
          "OSPF Local Node Router ID";
      }

      leaf ipfrr-area-revision {
        type uint32;
        description
          "IPFRR Topology Revision";
      }

      list ipfrr-topo {
        description "IPFRR Topology entries";
        uses OSPF-SH-IPFRR-TOPO-ENTRY;
      }  // list ipfrr-topo
    }  // grouping OSPFV3-SH-IPFRR-TOPO

    grouping OSPFV3-SH-BAD-CHECKSUM {
      description "OSPFv3 Bad Checksum";
      container timestamp {
        description
          "Packet Timestamp (relative to 1970/1/1 00:00)";
        uses OSPFV3-EDM-TIME;
      }  // container timestamp

      leaf received-checksum {
        type uint16;
        description
          "Received Checksum value";
      }

      leaf computed-checksum {
        type uint16;
        description
          "Computed Checksum value";
      }

      leaf received-data {
        type yang:hex-string;
        description
          "Received Hexadecimal Data";
      }
    }  // grouping OSPFV3-SH-BAD-CHECKSUM

    grouping OSPFV3-SH-STATS-AGGT {
      description "OSPFV3 SH STATS AGGT";
      leaf neighbor-number {
        type uint32;
        description "Number of neighbor";
      }

      leaf adjacent-neighbor-number {
        type uint32;
        description
          "Number of adjacent neighbor";
      }

      leaf interface-number {
        type uint32;
        description "Number of interfaces";
      }

      leaf interface-up-number {
        type uint32;
        description
          "Number of interfaces in UP state";
      }

      leaf virtual-link-up-number {
        type uint32;
        description
          "Number of Virtual link in UP state";
      }

      leaf sham-link-up-number {
        type uint32;
        description
          "Number of Sham link in UP state";
      }

      leaf area-numaber {
        type uint32;
        description "Number of Area";
      }

      leaf unknown-lsa-count {
        type uint32;
        description "Unknown LSA count";
      }

      leaf router-lsa-count {
        type uint32;
        description "Router LSA count";
      }

      leaf network-lsa-count {
        type uint32;
        description "Network LSA count";
      }

      leaf inter-area-prefix-lsa-count {
        type uint32;
        description
          "Inter Area Prefix LSA Count";
      }

      leaf inter-area-router-lsa-count {
        type uint32;
        description
          "Inter Area Router LSA Count";
      }

      leaf ase-lsa-count {
        type uint32;
        description "ASE LSA count";
      }

      leaf mospf-lsa-count {
        type uint32;
        description "MOSPF LSA count";
      }

      leaf type7-ase-lsa-count {
        type uint32;
        description "Type-7 ASE LSA count ";
      }

      leaf link-lsa-count {
        type uint32;
        description "Link LSA count";
      }

      leaf prefix-lsa-count {
        type uint32;
        description "Prefix LSA count";
      }

      leaf type10lsa-count {
        type uint32;
        description "Type-10 LSA count";
      }

      leaf grace-lsa-count {
        type uint32;
        description "Grace LSA count";
      }

      leaf opaque-link-lsa-count {
        type uint32;
        description "Opaque Link LSA count";
      }

      leaf opaque-area-lsa-count {
        type uint32;
        description "Opaque Area LSA count";
      }

      leaf opaque-as-lsa-count {
        type uint32;
        description "Opaque AS LSA count";
      }

      leaf unknown-area-lsa-count {
        type uint32;
        description "Unknown Area LSA count";
      }

      leaf unknown-link-lsa-count {
        type uint32;
        description "Unknown Link LSA count";
      }

      leaf unknown-as-lsa-count {
        type uint32;
        description "Unknown AS LSA count";
      }
    }  // grouping OSPFV3-SH-STATS-AGGT

    grouping OSPF-SH-IPFRR-TB {
      description "OSPF IPFRR Tiebreakers";
      leaf tiebreaker-type {
        type Ipfrr-tbrkr;
        description "Tiebreaker Type used";
      }

      leaf tiebreaker-index {
        type uint32;
        description
          "Index of the Tiebreaker";
      }
    }  // grouping OSPF-SH-IPFRR-TB

    grouping OSPFV3-SH-STUB-ROUTER-TRIGGER {
      description
        "OSPFv3 stub router trigger information";
      container unset-time {
        description
          "Timestamp (relative to 1970/1/1 00:00) when stub
         router condition was cleared";
        uses OSPFV3-EDM-TIME;
      }  // container unset-time

      container start-time {
        description
          "Timestamp (relative to 1970/1/1 00:00) when stub
         router mode was activated";
        uses OSPFV3-EDM-TIME;
      }  // container start-time

      leaf trigger {
        type Stub-router-trigger;
        description
          "Stub Router Trigger type";
      }

      leaf wait-for-bgp {
        type boolean;
        description
          "If true, stub router is terminated when BGP
         converges";
      }

      leaf unset-reason {
        type Stub-router-exit-reason;
        description
          "Reason for clearing stub router condition";
      }

      leaf time {
        type uint32;
        units "second";
        description
          "Time (in seconds) to stay in stub router mode";
      }
    }  // grouping OSPFV3-SH-STUB-ROUTER-TRIGGER

    grouping OSPFV3-EDM-TIME {
      description "OSPFv3 time stamp";
      leaf second {
        type uint32;
        units "second";
        description "Seconds ";
      }

      leaf nanosecond {
        type uint32;
        units "nanosecond";
        description "Nano seconds ";
      }
    }  // grouping OSPFV3-EDM-TIME

    grouping OSPFV3-SH-STUB-ROUTER {
      description
        "OSPFv3 Stub Router Information";
      container unset-time {
        description
          "Timestamp (relative to 1970/1/1 00:00) when stub
         router condition was cleared";
        uses OSPFV3-EDM-TIME;
      }  // container unset-time

      container start-time {
        description
          "Timestamp (relative to 1970/1/1 00:00) when stub
         router mode was activated";
        uses OSPFV3-EDM-TIME;
      }  // container start-time

      container abr-resume-time {
        description
          "Timestamp (relative to 1970/1/1 00:00) when ABR
         duties were resumed";
        uses OSPFV3-EDM-TIME;
      }  // container abr-resume-time

      leaf mode {
        type Stub-router-mode;
        description "Stub router mode";
      }

      leaf active {
        type boolean;
        description
          "If true, stub router mode is active";
      }

      leaf remaining-time {
        type uint32;
        units "second";
        description
          "Remaining time (in seconds) in stub router mode";
      }

      leaf set-reason {
        type Stub-router-trigger;
        description
          "Reason for entering stub router mode";
      }

      leaf unset-reason {
        type Stub-router-exit-reason;
        description
          "Reason for clearing stub router condition";
      }

      leaf include-stub-links {
        type boolean;
        description
          "If true, advertise maximum metric for stub links";
      }

      leaf summary-lsa-metric {
        type uint32;
        description
          "Metric for summary LSAs in max-metric mode";
      }

      leaf external-lsa-metric {
        type uint32;
        description
          "Metric for external LSAs in max-metric mode";
      }

      leaf abr-off-reason {
        type Stub-router-abr-off-reason;
        description
          "Reason for being in ABR off mode";
      }

      list trigger {
        description
          "Triggers for entering stub router mode";
        uses OSPFV3-SH-STUB-ROUTER-TRIGGER;
      }  // list trigger
    }  // grouping OSPFV3-SH-STUB-ROUTER

    grouping OSPFV3-SH-DOMAIN-ID-ENTRY {
      description "OSPF Domain ID";
      leaf domain-id-type {
        type uint16;
        description "Domain ID Type";
      }

      leaf domain-id-value {
        type yang:hex-string;
        description "Domain ID value";
      }
    }  // grouping OSPFV3-SH-DOMAIN-ID-ENTRY

    grouping OSPFV3-SH-DOMAIN-ID {
      description "OSPF Domain ID entries";
      container primary-domain-id {
        description "Primary Domain ID";
        uses OSPFV3-SH-DOMAIN-ID-ENTRY;
      }  // container primary-domain-id

      list secondary-domain-id {
        description
          "List of secondary domain IDs";
        uses OSPFV3-SH-DOMAIN-ID-ENTRY;
      }  // list secondary-domain-id
    }  // grouping OSPFV3-SH-DOMAIN-ID

    grouping OSPFV3-EDM-SUMMARY {
      description "OSPFv3 summary";
      container domain-id {
        description "Domain ID information";
        uses OSPFV3-SH-DOMAIN-ID;
      }  // container domain-id

      leaf router-id {
        type inet:ipv4-address;
        description "Router ID";
      }

      leaf is-role-standby {
        type boolean;
        description
          "If true, the process is running as stanby role";
      }

      leaf role {
        type uint32;
        description
          "Role, V1/V2 Active/Standby";
      }

      leaf is-nsr-enabled {
        type boolean;
        description
          "If true, NSR is enabled";
      }

      leaf is-nsr-switchover-on-restart {
        type boolean;
        description
          "Trigger RP Switchover on detectable process
         restart";
      }

      leaf is-router-id-stalled {
        type boolean;
        description "Stalled Router ID ";
      }

      leaf is-opaque-capable {
        type boolean;
        description "Opaque LSA capable ";
      }

      leaf is-area-border-router {
        type boolean;
        description
          "If true, is an area border router";
      }

      leaf is-as-border-router {
        type boolean;
        description
          "If true, is an AS border router";
      }

      leaf capability-prefer-type7 {
        type boolean;
        description
          "If true, prefer type 7 LSAs over type 5";
      }

      leaf metric {
        type uint32;
        description "Redistribution metric ";
      }

      leaf is-default-originated {
        type boolean;
        description
          "If true, default route LSA is originated";
      }

      leaf is-default-always {
        type boolean;
        description
          "If true, default route LSA is originated always";
      }

      leaf default-metric {
        type uint32;
        description
          "Metric for the redistributed default route";
      }

      leaf default-metric-type {
        type Ospfv3-default-metric;
        description
          "Default metric type to be used if not
         specifically configured";
      }

      leaf default-tag {
        type uint32;
        description
          "Route tag of the default route LSA";
      }

      leaf is-default-policy {
        type boolean;
        description
          "If true, there is a default route policy ";
      }

      leaf default-policy-name {
        type string;
        description
          "Default route policy name ";
      }

      leaf spf-start-time {
        type uint32;
        description
          "Scheduling delay for SPF (ms)";
      }

      leaf spf-hold-time {
        type uint32;
        description
          "Minimum delay time between SPF runs (ms)";
      }

      leaf spf-maximum-time {
        type uint32;
        description
          "Maximum delay time between SPF runs (ms)";
      }

      leaf lsa-start-time {
        type uint32;
        description
          "Initial LSA throttle delay (ms)";
      }

      leaf lsa-hold-time {
        type uint32;
        description
          "Second delay before generating next LSA (ms)";
      }

      leaf lsa-maximum-time {
        type uint32;
        description
          "Maximum delay before generating an LSA (ms)";
      }

      leaf minimum-lsa-interval {
        type uint32;
        description
          "Minimum time between LSA regeneration (ms)";
      }

      leaf lsa-group-interval {
        type uint32;
        description
          "LSA refresh interval (sec)";
      }

      leaf lsa-flood-pacing-interval {
        type uint32;
        description
          "LSA flood pacing timer (ms)";
      }

      leaf lsa-retransmission-pacing-interval {
        type uint32;
        description
          "LSA retransmission pacing timer (ms)";
      }

      leaf as-ls-as {
        type uint32;
        description
          "Number of AS scope LSAs";
      }

      leaf opaque-lsas {
        type uint32;
        description "Number of opaque LSAs";
      }

      leaf opaque-lsa-checksum {
        type uint32;
        description
          "Sum of opaque LSA checksum";
      }

      leaf as-dc-bitless-ls-as {
        type uint32;
        description
          "Number of external and AS opaque LSAs with
         demand circut bit not set";
      }

      leaf as-do-not-age-ls-as {
        type uint32;
        description
          "Number of external and AS opaque LSAs with do
         not age set ";
      }

      leaf areas {
        type uint16;
        description "Number of areas";
      }

      leaf normal-areas {
        type uint16;
        description "Number of normal areas";
      }

      leaf stub-areas {
        type uint16;
        description
          "Number of stub and total stub areas";
      }

      leaf nssa-areas {
        type uint16;
        description "Number of NSSA areas";
      }

      leaf as-lsa-flood-list-length {
        type uint32;
        description
          "Length of AS LSAs flood list";
      }

      leaf is-grace-restart-enabled {
        type boolean;
        description
          "If true, grace restart is enabled ";
      }

      leaf last-nsf-time {
        type uint32;
        description
          " Length of time since the last NSF (s)";
      }

      leaf grace-resync-time {
        type uint32;
        description "Grace time to resync ";
      }

      leaf maximum-interfaces {
        type uint32;
        description
          "Maximum number of interfaces";
      }

      leaf maximum-paths {
        type uint32;
        description
          "Maximum number of paths";
      }

      leaf redistribution-limit {
        type uint32;
        description
          "The number of redistributed prefixes allowed";
      }

      leaf redistribution-threshold {
        type uint32;
        description
          "When the number of redistributed prefixes
         reaches this threshold, a warning message is
         issued ";
      }

      leaf is-auto-cost {
        type boolean;
        description
          "If true, auto cost is enabled";
      }

      leaf reference-bandwidth {
        type uint32;
        description
          "Reference Bandwdith used for metric calculation";
      }

      leaf context-name {
        type string {
          length "0..32";
        }
        description "SNMP Context name";
      }

      leaf snmp-trap-enabled {
        type boolean;
        description
          "If true, snmp trap is enabled";
      }

      leaf graceful-shutdown-state {
        type Ospfv3-graceful-shutdown-state;
        description
          "Graceful shutdown state of OSPFv3";
      }

      list stub-router {
        description
          "Stub Router Information";
        uses OSPFV3-SH-STUB-ROUTER;
      }  // list stub-router

      list ipfrr-tiebreakers {
        description "IPFRR-Tiebreakers list";
        uses OSPF-SH-IPFRR-TB;
      }  // list ipfrr-tiebreakers
    }  // grouping OSPFV3-EDM-SUMMARY

    grouping OSPFV3-EDM-PROTOCOL {
      description
        "OSPFv3 Protocol Information";
      leaf protocol-router-id {
        type inet:ipv4-address;
        description "OSPFv3 router ID";
      }

      leaf administrative-distance {
        type uint32;
        description
          "Administrative distance of OSPFv3 routes";
      }

      leaf administrative-distance-inter-area {
        type uint32;
        description
          "Administrative Distance for Inter Area routes";
      }

      leaf administrative-distance-external {
        type uint32;
        description
          "Administrative Distance for External routes";
      }

      leaf is-graceful-restart {
        type boolean;
        description
          "If true, Graceful restart is enabled ";
      }

      leaf distribute-list-in {
        type string;
        description
          "Name of the ACL specified as Distribute List";
      }
    }  // grouping OSPFV3-EDM-PROTOCOL

    grouping OSPFV3-EDM-BATCH-STATS {
      description
        "OSPFv3 RIB batch statistics";
      leaf batches-sent {
        type uint32;
        description
          "No. of RIB batches sent";
      }

      leaf routes-sent {
        type uint32;
        description
          "No. of Routes sent to RIB";
      }

      leaf routes-pending {
        type uint32;
        description "No of Pending Routes";
      }

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

      leaf paths-sent {
        type uint32;
        description
          "No. of Paths sent to RIB";
      }

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

      leaf paths-add {
        type uint32;
        description
          "No. of paths added to RIB";
      }

      leaf paths-add-errs {
        type uint32;
        description
          "No. of paths add errors";
      }

      leaf paths-del {
        type uint32;
        description
          "No. of paths del sent to RIB";
      }

      leaf paths-del-errs {
        type uint32;
        description
          "No. of Paths del errors";
      }
    }  // grouping OSPFV3-EDM-BATCH-STATS

    grouping OSPFV3-EDM-PRIO-STATS {
      description
        "OSPFv3 SPF prefix priority classification
       statistics";
      leaf critical {
        type uint32;
        description
          "Critical priority classifications";
      }

      leaf high {
        type uint32;
        description
          "High priority classifications";
      }

      leaf medium {
        type uint32;
        description
          "Medium priority classifications";
      }

      leaf low {
        type uint32;
        description
          "Low priority classifications";
      }
    }  // grouping OSPFV3-EDM-PRIO-STATS

    grouping OSPFV3-EDM-RAW-STATS {
      description
        "OSPFv3 raw I/O statistics";
      leaf raw-conn-open {
        type uint64;
        description "Raw Connections Open";
      }

      leaf raw-conn-close {
        type uint64;
        description "Raw Connections Close";
      }

      leaf raw-conn-error {
        type uint64;
        description "Raw Connections Error";
      }

      leaf in-packets {
        type uint64;
        description "Received Packets";
      }

      leaf in-bytes {
        type uint64;
        units "byte";
        description "Received Bytes";
      }

      leaf in-long-packets {
        type uint64;
        description "Received Long Packets";
      }

      leaf in-malloc-drops {
        type uint64;
        description "In Malloc Drops";
      }

      leaf in-handle-drops {
        type uint64;
        description "In Handle Drops";
      }

      leaf in-short-drops {
        type uint64;
        description "In Short Drops";
      }

      leaf in-error-drops {
        type uint64;
        description "In Error Drops";
      }

      leaf in-ipsec-drops {
        type uint64;
        description "In IPSEC Drops";
      }

      leaf in-queue-drops {
        type uint64;
        description "In Queue Drops";
      }

      leaf out-packets {
        type uint64;
        description "Packets Sent";
      }

      leaf out-bytes {
        type uint64;
        units "byte";
        description "Sent Bytes";
      }

      leaf out-nofd-drops {
        type uint64;
        description
          "No FileDescriptor Drops";
      }

      leaf out-error-drops {
        type uint64;
        description "Error Drops";
      }

      leaf out-ipsec-drops {
        type uint64;
        description "Out IPSEC Drops";
      }

      leaf out-nopak-drops {
        type uint64;
        description "No Packet Buffers";
      }

      leaf out-pakapi-errors {
        type uint64;
        description "PAK API Errors";
      }

      leaf raw-conn-state {
        type uint32;
        description "Raw Connection State";
      }
    }  // grouping OSPFV3-EDM-RAW-STATS

    grouping OSPFV3-EDM-SPF-AREA-STATS {
      description
        "OSPFv3 SPF Area Statistics Information";
      container spf-stat-time {
        description "SPF time calculations";
        uses OSPFV3-SPF-TIME;
      }  // container spf-stat-time

      leaf spf-stat-area-id {
        type uint32;
        description
          "Area ID for area of these SPF statistics";
      }

      list spf-stat-lsa-type-count {
        max-elements 8;
        description
          "Counts of LSA types triggering an SPF
         calculation";
        leaf entry {
          type uint32;
          description
            "Counts of LSA types triggering an SPF
           calculation";
        }
      }  // list spf-stat-lsa-type-count
    }  // grouping OSPFV3-EDM-SPF-AREA-STATS

    grouping OSPFV3-LSA-CHANGE {
      description
        "OSPFv3 LSA Change Information";
      leaf lsa-area-id {
        type uint32;
        description "Area ID";
      }

      leaf lsa-advertising-router {
        type inet:ipv4-address;
        description "Advertising router ID";
      }

      leaf lsa-id {
        type inet:ipv4-address;
        description "LSA ID";
      }

      leaf lsa-type {
        type uint8;
        description "LSA type";
      }

      leaf lsa-flush {
        type boolean;
        description
          "If true, the LSA change is a flush";
      }
    }  // grouping OSPFV3-LSA-CHANGE

    grouping OSPFV3-SPF-TIME {
      description
        "OSPFv3 SPF Time Information";
      leaf dijkstra {
        type uint32;
        description "Dijkstra time in msec";
      }

      leaf intra-prefix {
        type uint32;
        description
          "Intra-prefix processing time in msec";
      }

      leaf intra-prefix-del {
        type uint32;
        description
          "Intra-prefix deletion time in msec";
      }

      leaf inter-prefix {
        type uint32;
        description
          "Inter-prefix processing time in msec";
      }

      leaf inter-prefix-del {
        type uint32;
        description
          "Intra-prefix deletion time in msec";
      }

      leaf external-prefix {
        type uint32;
        description
          "External prefix processing time in msec";
      }

      leaf external-prefix-del {
        type uint32;
        description
          "External prefix deletion time in msec";
      }

      leaf rib-add {
        type uint32;
        description
          "RIB add processing time in msec";
      }

      leaf rib-del {
        type uint32;
        description
          "RIB deletion time in msec";
      }
    }  // grouping OSPFV3-SPF-TIME

    grouping OSPFV3-RUNTIME-STATS {
      description
        "OSPFv3 SPF Runtime Statistics Information";
      container global-time {
        description "Global SPF times";
        uses OSPFV3-SPF-TIME;
      }  // container global-time

      leaf start-time {
        type uint32;
        description
          "SPF calculation start time";
      }

      leaf rib-add-routes {
        type uint32;
        description
          "Number of routes added to RIB";
      }

      leaf rib-delete-routes {
        type uint32;
        description
          "Number of routes deleted from RIB";
      }

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

      leaf reason-flags {
        type yang:hex-string;
        description
          "Reasons for triggering an SPF calculation Bit 1
         - Router LSA update Bit 2 - Network LSA update
         Bit 3 - Inter-Area Prefix LSA update Bit 4 -
         Inter-Area Router LSA update Bit 5 - AS External
         LSA update Bit 6 - MOSPF LSA update Bit 7 - Type
         7 AS External LSA update Bit 8 - Link LSA update
         Bit 9 - Prefix LSA update";
      }

      leaf lsa-changes {
        type int16;
        description
          "Number of LSA changes triggering an SPF
         calculation";
      }

      list lsa {
        max-elements 5;
        description
          "List of LSAs triggering the SPF calculation";
        uses OSPFV3-LSA-CHANGE;
      }  // list lsa

      list area-stat {
        description
          "List of per-area SPF statistics";
        uses OSPFV3-EDM-SPF-AREA-STATS;
      }  // list area-stat
    }  // grouping OSPFV3-RUNTIME-STATS

    grouping OSPFV3-EDM-AREA-SUMM {
      description
        "OSPFv3 Area SPF Information";
      leaf area-id {
        type uint32;
        description
          "Area ID of the area SPF statistics";
      }

      leaf sp-fs {
        type uint32;
        description
          "Number of SPF calculations";
      }
    }  // grouping OSPFV3-EDM-AREA-SUMM

    grouping OSPFV3-HEADER-INFO {
      description
        "OSPFv3 SPF Statistics Header Information";
      leaf header-router-id {
        type inet:ipv4-address;
        description "Router ID";
      }

      leaf header-sp-fs {
        type uint32;
        description
          "Number of SPF calculations";
      }

      list area-summary {
        description
          "List of Areas with SPF statistics";
        uses OSPFV3-EDM-AREA-SUMM;
      }  // list area-summary
    }  // grouping OSPFV3-HEADER-INFO

    grouping OSPFV3-EDM-SPF-STATS {
      description "OSPFv3 SPF statistics";
      container spf-header {
        description "SPF statistics header";
        uses OSPFV3-HEADER-INFO;
      }  // container spf-header

      list spf-runtime {
        description
          "List of SPF run-time statistics";
        uses OSPFV3-RUNTIME-STATS;
      }  // list spf-runtime
    }  // grouping OSPFV3-EDM-SPF-STATS

    grouping OSPFV3-EDM-PROTO-STATS {
      description
        "OSPFv3 protocol statistics";
      leaf total-in-packets {
        type uint64;
        description "Total packets in";
      }

      leaf hello-in-packets {
        type uint64;
        description "Hello packets in";
      }

      leaf dbdes-in-packets {
        type uint64;
        description
          "Database Description Packets in";
      }

      leaf dbdes-in-ls-as {
        type uint64;
        description
          "Database Description LSAs in";
      }

      leaf ls-req-in-packets {
        type uint64;
        description "LSA Requests in";
      }

      leaf ls-req-in-ls-as {
        type uint64;
        description "LS Requests in";
      }

      leaf ls-upd-in-packets {
        type uint64;
        description "LS Updates Packets in";
      }

      leaf ls-upd-in-ignored {
        type uint64;
        description "LS Updates ignored";
      }

      leaf ls-upd-in-ls-as {
        type uint64;
        description "LS Updates LSAs in";
      }

      leaf ls-ack-in-packets {
        type uint64;
        description "LS Acks Packets in";
      }

      leaf ls-ack-in-ls-as {
        type uint64;
        description "LS Ack LSAs in";
      }

      leaf total-out-packets {
        type uint64;
        description "Total Packets sent out";
      }

      leaf hello-out-packets {
        type uint64;
        description "Hello Packets sent out";
      }

      leaf dbdes-out-packets {
        type uint64;
        description
          "Database Description Packets out";
      }

      leaf dbdes-out-ls-as {
        type uint64;
        description
          "Database Description LSAs out";
      }

      leaf ls-req-out-packets {
        type uint64;
        description "LS Request Packets out";
      }

      leaf ls-req-out-ls-as {
        type uint64;
        description "LS Reuqests LSAs out";
      }

      leaf ls-upd-out-packets {
        type uint64;
        description "LS Update Packets out";
      }

      leaf ls-upd-out-ls-as {
        type uint64;
        description "LS Update LSAs out";
      }

      leaf ls-ack-out-packets {
        type uint64;
        description "LS Ack Packets out";
      }

      leaf ls-ack-out-ls-as {
        type uint64;
        description "LS Ack LSAs out";
      }

      leaf dropped-in-gs {
        type uint64;
        description "Dropped in GS";
      }

      leaf checksum-err {
        type uint64;
        description "Checksum Errors";
      }
    }  // grouping OSPFV3-EDM-PROTO-STATS

    grouping OSPFV3-EDM-TOPOLOGY-CONNECTED {
      description
        "OSPFv3 Topology Connected Information";
      container route-topology {
        description
          "Common Route topology information";
        uses OSPFV3-EDM-TOPOLOGY;
      }  // container route-topology

      list route-path {
        description
          "List of paths to this route";
        uses OSPFV3-EDM-TOP-PATH;
      }  // list route-path
    }  // grouping OSPFV3-EDM-TOPOLOGY-CONNECTED

    grouping OSPFV3-EDM-PROTO-INTF {
      description
        "OSPFv3 Protocol Interface Information";
      leaf interface-name {
        type xr:Interface-name;
        description
          "Protocol interface name ";
      }

      leaf distribute-list-in {
        type string;
        description
          "Name of the ACL specified as Distribute List";
      }
    }  // grouping OSPFV3-EDM-PROTO-INTF

    grouping OSPFV3-EDM-PROTO-AREA {
      description
        "OSPFv3 Protocol Area Information";
      leaf protocol-area-id {
        type string {
          length "0..16";
        }
        description
          "Area ID string in decimal and dotted-decimal
         format";
      }

      leaf distribute-list-in {
        type string;
        description
          "Name of the ACL specified as Distribute List";
      }

      list protocol-interface {
        description "Interface list";
        uses OSPFV3-EDM-PROTO-INTF;
      }  // list protocol-interface
    }  // grouping OSPFV3-EDM-PROTO-AREA

    grouping OSPFV3-SH-SLINK-NEIGHBOR {
      description
        "Sham Link Neighbor Information";
      container sham-link-retransmission {
        description
          "Neighbor retransmission info";
        uses OSPFV3-EDM-NEIGHBOR-RETRANS;
      }  // container sham-link-retransmission

      leaf sham-link-suppress-hello {
        type boolean;
        description
          "If true Hellos suppressed";
      }

      leaf sham-link-state {
        type Ospfv3-neighbor-state;
        description "Adjacency state";
      }
    }  // grouping OSPFV3-SH-SLINK-NEIGHBOR

    grouping OSPFV3-SH-SHAM-LINKS {
      description "OSPFv3 Sham Link";
      container sham-link-neighbor {
        description "Neighbor information";
        uses OSPFV3-SH-SLINK-NEIGHBOR;
      }  // container sham-link-neighbor

      leaf sham-link-neighbor-id {
        type inet:ipv4-address;
        description
          "Neighbor on other end of this sham link";
      }

      leaf sham-link-source-address {
        type inet:ipv6-address;
        description "Sham-link source";
      }

      leaf sham-link-dest-address {
        type inet:ipv6-address;
        description "Sham-link dest";
      }

      leaf sham-link-state {
        type Ospfv3-interface-state;
        description
          "OSPF interface state for the sham link";
      }

      leaf sham-link-demand-circuit {
        type boolean;
        description
          "If true, the link runs as demand circuit";
      }

      leaf sham-link-dc-bitless-lsa {
        type uint32;
        description
          "Number of LSA's with demand circuit bit not set";
      }

      leaf sham-link-ifindex {
        type uint32;
        description
          "Ifindex of the shamlink";
      }

      leaf sham-link-area {
        type string;
        description "Area id";
      }

      leaf sham-link-cost {
        type uint16;
        description "Cost of the sham link";
      }

      leaf sham-link-transmission-delay {
        type uint16;
        units "second";
        description
          "Transmission delay in seconds";
      }

      leaf sham-link-hello-interval {
        type uint32;
        description "Hello interval (s)";
      }

      leaf sham-link-dead-interval {
        type uint32;
        description "Dead interval (s)";
      }

      leaf sham-link-wait-interval {
        type uint32;
        description "Wait interval (s)";
      }

      leaf sham-link-retransmission-interval {
        type uint32;
        description
          "Retransmission interval (s)";
      }

      leaf sham-link-next-hello {
        type uint32;
        description
          "Time until next hello (s)";
      }

      leaf sham-link-passive {
        type boolean;
        description
          "If true, interface is passive";
      }

      leaf is-sham-link-ip-security-required {
        type boolean;
        description
          "If true, sham link IP security is required ";
      }

      leaf is-sham-link-ip-security-active {
        type boolean;
        description
          "If true, Sham link IP security is active ";
      }

      leaf is-sham-link-authentication-enabled {
        type boolean;
        description
          "If true, authentication is enabled for the sham
         link";
      }

      leaf virtual-link-authentication-spi {
        type uint32;
        description
          "Authentication Security Parameter Index for the
         sham link";
      }

      leaf sham-link-authentication-transmit {
        type uint32;
        description
          "Authentication algorithm for the sham link";
      }

      leaf is-sham-link-encryption-enabled {
        type boolean;
        description
          "If true, encryption is enabled for the sham link";
      }

      leaf sham-link-encryption-spi {
        type uint32;
        description
          "Encryption Security Parameter Index for the sham
         link";
      }

      leaf sham-link-encryption-transmitted {
        type uint32;
        description
          "Algorithm for the sham link";
      }

      leaf sham-link-encrypted-authentication-transmitted {
        type uint32;
        description
          "Encrypted Authentication algorithm for the sham
         link";
      }

      leaf sham-link-gr-enabled {
        type boolean;
        description
          "If true, graceful restart is enabled";
      }

      leaf sham-link-gr {
        type boolean;
        description
          "If true, Gracefule restart is in progress";
      }

      leaf sham-link-last-gr {
        type uint32;
        units "second";
        description
          "Time in seconds since last GR";
      }
    }  // grouping OSPFV3-SH-SHAM-LINKS

    grouping OSPFV3-EDM-TOP-SOURCE {
      description
        "OSPFv3 topology source information";
      leaf route-source-adversting-router {
        type inet:ipv4-address;
        description
          "Source of route for the advertising router";
      }

      leaf route-source-id {
        type inet:ipv4-address;
        description "Route source ID ";
      }

      leaf route-source-lsa-type {
        type uint32;
        description
          "Type of LSA advertising the prefix, see RFC5340";
      }
    }  // grouping OSPFV3-EDM-TOP-SOURCE

    grouping OSPFV3-EDM-TOPOLOGY-INTERNAL {
      description
        "OSPFv3 Topology Internal Information";
      container route-topology {
        description
          "Common Route topology information";
        uses OSPFV3-EDM-TOPOLOGY;
      }  // container route-topology

      leaf route-area-id {
        type uint32;
        description "Route area ID ";
      }

      list route-source {
        description
          "List of topology source information";
        uses OSPFV3-EDM-TOP-SOURCE;
      }  // list route-source

      list route-path {
        description
          "List of paths to this route";
        uses OSPFV3-EDM-TOP-PATH;
      }  // list route-path
    }  // grouping OSPFV3-EDM-TOPOLOGY-INTERNAL

    grouping OSPFV3-EDM-RETRANS {
      description
        "OSPFv3 retransmission list information";
      leaf retransmission-neighbor-address {
        type inet:ipv6-address;
        description "Neighbor IP address";
      }

      leaf is-retransmissionvirtual-link {
        type boolean;
        description
          "If true, retransmission is over a virtual link";
      }

      leaf retransmissionvirtual-link-id {
        type uint32;
        description
          "Virtual link ID if Retransmission is over a
         virtual link";
      }

      leaf is-retransmission-sham-link {
        type boolean;
        description
          "If true, retransmission is over a sham link";
      }

      leaf retransmission-sham-link-id {
        type uint32;
        description
          "Sham link ID if Retransmission is over a sham
         link";
      }

      leaf retransmission-timer {
        type uint32;
        description
          "Amount of time remaining on retransmission timer
         (ms)";
      }

      leaf retransmission-length {
        type uint32;
        description
          "Current length of the Retransmission queue";
      }

      list retransmissionvirtual-link-db {
        description
          "List of virtual link scope entries ";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list retransmissionvirtual-link-db

      list retransmission-area-db {
        description
          "List of area scope entries";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list retransmission-area-db

      list retransmission-asdb {
        description
          "List of AS scope entries";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list retransmission-asdb
    }  // grouping OSPFV3-EDM-RETRANS

    grouping OSPFV3-EDM-DB-SUMMARY-COUNTERS {
      description
        "OSPFv3 Database Summary Counters";
      list lsa {
        max-elements 15;
        description "Total LSA count";
        leaf entry {
          type uint32;
          description "Total LSA count";
        }
      }  // list lsa

      list deleted-lsa {
        max-elements 15;
        description "Count of LSAs deleted";
        leaf entry {
          type uint32;
          description
            "Count of LSAs deleted";
        }
      }  // list deleted-lsa

      list max-age-lsa {
        max-elements 15;
        description "Count of LSAs maxaged";
        leaf entry {
          type uint32;
          description
            "Count of LSAs maxaged";
        }
      }  // list max-age-lsa

      list lsa-checksum {
        max-elements 15;
        description
          "Sum of LSA checksum values";
        leaf entry {
          type uint32;
          description
            "Sum of LSA checksum values";
        }
      }  // list lsa-checksum
    }  // grouping OSPFV3-EDM-DB-SUMMARY-COUNTERS

    grouping OSPFV3-EDM-DB-SUMMARY-AREA {
      description
        "OSPFv3 Area Database Summary";
      container area-database-summary {
        description
          "Summary of Area database";
        uses OSPFV3-EDM-DB-SUMMARY-COUNTERS;
      }  // container area-database-summary

      leaf lsa-area-id {
        type string {
          length "0..16";
        }
        description
          "Area ID in decimal or dotted-decimal format";
      }
    }  // grouping OSPFV3-EDM-DB-SUMMARY-AREA

    grouping OSPFV3-EDM-DB-SUMMARY {
      description "OSPFv3 Database Summary";
      container database-counters {
        description
          "OSPFv3 database statistics";
        uses OSPFV3-EDM-DB-SUMMARY-COUNTERS;
      }  // container database-counters

      leaf database-router-id {
        type inet:ipv4-address;
        description "Self router ID ";
      }

      leaf is-opaque-database-capable {
        type boolean;
        description
          "If true, opaque database is capable ";
      }

      list area-database {
        description
          "OSPFv3 Area Database list ";
        uses OSPFV3-EDM-DB-SUMMARY-AREA;
      }  // list area-database
    }  // grouping OSPFV3-EDM-DB-SUMMARY

    grouping OSPFV3-EDM-INTF-BRIEF {
      description
        "OSPFv3 brief interface information";
      leaf interface-address {
        type inet:ipv6-address;
        description
          "IP address of the interface";
      }

      leaf interface-link-cost {
        type uint16;
        description
          "Link cost/metric of this interface";
      }

      leaf ospf-interface-state {
        type Ospfv3-interface-state;
        description "Interface OSPF state";
      }

      leaf interface-neighbors {
        type uint16;
        description
          "Total number of neighbors ";
      }

      leaf interface-adjacent-neighbors {
        type uint16;
        description
          "Total number of adjacent neighbors";
      }

      leaf network-type {
        type Ospfv3-interface;
        description
          "OSPFv3 Network type of the interface";
      }
    }  // grouping OSPFV3-EDM-INTF-BRIEF

    grouping OSPFV3-EDM-NEIGHBOR-BFD {
      description
        "OSPFv3 Neighbor BFD information";
      leaf bfd-intf-enable-mode {
        type uint32;
        description
          "BFD enable mode - Default/Strict";
      }

      leaf bfd-status-flag {
        type uint8;
        description
          "Status of the BFD Session";
      }
    }  // grouping OSPFV3-EDM-NEIGHBOR-BFD

    grouping OSPFV3-EDM-NEIGHBOR-DETAIL {
      description
        "Detailed OSPFv3 neighbor information";
      container neighbor-retransmission {
        description
          "Retransmission information with this neighbor";
        uses OSPFV3-EDM-NEIGHBOR-RETRANS;
      }  // container neighbor-retransmission

      leaf state-changes {
        type uint16;
        description
          "Number of state changes ";
      }

      leaf neighbor-cost {
        type uint16;
        description
          "Cost of path to this neighbor ";
      }

      leaf is-neighbor-filtered {
        type boolean;
        description
          "If true, filter outgoing LSAs ";
      }

      leaf neighbor-designated-router-address {
        type inet:ipv4-address;
        description
          "Address of designated router";
      }

      leaf neighbor-backup-designated-router-address {
        type inet:ipv4-address;
        description
          "Address of backup designated router";
      }

      leaf interface-type {
        type Ospfv3-interface;
        description "Type of Interface";
      }

      leaf poll-interval {
        type uint32;
        description "Poll interval (s)";
      }

      leaf next-poll-interval {
        type uint32;
        units "second";
        description
          "For NBMA networks, amount of time remaining in
         seconds before the next poll interval expires
         and Hello is sent (s)";
      }

      leaf neighbor-ignore-timer {
        type uint32;
        description
          "Remaining time when ignore timer is running ";
      }

      leaf neighbor-option {
        type uint32;
        description
          " This is bitmask of neighbor's option field
         received ";
      }

      leaf pending-events {
        type uint16;
        description
          "Number of pending events ";
      }
    }  // grouping OSPFV3-EDM-NEIGHBOR-DETAIL

    grouping OSPFV3-EDM-NEIGHBOR {
      description
        "OSPFv3 neighbor summary information";
      container neighbor-detail {
        description
          "Detailed OSPFv3 neighbor information ";
        uses OSPFV3-EDM-NEIGHBOR-DETAIL;
      }  // container neighbor-detail

      container neighbor-bfd-info {
        description
          "Neighbor BFD information";
        uses OSPFV3-EDM-NEIGHBOR-BFD;
      }  // container neighbor-bfd-info

      leaf neighbor-address-xr {
        type inet:ipv6-address;
        description "Neighbor IP Address";
      }

      leaf neighbor-interface-id {
        type uint32;
        description
          "Interface ID of the neighbor";
      }

      leaf neighbor-dr-priority {
        type uint8;
        description
          "DR priority of the neighbor";
      }

      leaf neighbor-state {
        type Ospfv3-neighbor-state;
        description
          "NFSM state of the neighbor";
      }

      leaf neighbor-designated-router {
        type string {
          length "0..9";
        }
        description "Designated router ";
      }

      leaf neighbor-dead-timer {
        type uint32;
        units "second";
        description
          "Time until neighbor's dead timer expires
         (seconds)";
      }

      leaf neighbor-up-time {
        type uint32;
        units "second";
        description
          "Amount of time since the adjacency is up
         (seconds)";
      }

      leaf neighbor-virtual-link-id {
        type uint32;
        description
          "Virtual link id of the neighbor if this neighbor
         is on a virtual link";
      }

      leaf is-neighbor-virtual-link {
        type boolean;
        description
          "If true, neighbor is on a virtual link ";
      }

      leaf neighbor-sham-link-id {
        type uint32;
        description
          "Sham link id of the neighbor if this neighbor is
         on a sham link";
      }

      leaf is-neighbor-sham-link {
        type boolean;
        description
          "If true, neighbor is on a sham link ";
      }
    }  // grouping OSPFV3-EDM-NEIGHBOR

    grouping OSPFV3-EDM-ROUTE-SUM {
      description
        "OSPFv3 route summary information";
      leaf route-id {
        type inet:ipv4-address;
        description
          "Route summary of a route ID ";
      }

      leaf intra-area-route {
        type uint32;
        description "Intra route summary ";
      }

      leaf inter-area-route {
        type uint32;
        description "Inter route summary ";
      }

      leaf extern-one-route {
        type uint32;
        description
          "Extern 1 route summary ";
      }

      leaf extern-two-route {
        type uint32;
        description
          "Extern 2 route summary ";
      }

      leaf nssa-one-route {
        type uint32;
        description "NSSA 1 route summary ";
      }

      leaf nssa-two-route {
        type uint32;
        description "NSSA 2 route summary ";
      }

      leaf total-sent-route {
        type uint32;
        description "Total route summary ";
      }

      leaf route-connected {
        type uint32;
        description "Total connected routes";
      }

      leaf redistribution-route {
        type uint32;
        description
          "Redistribution route summary ";
      }

      leaf total-received-route {
        type uint32;
        description
          "Total route received summary";
      }
    }  // grouping OSPFV3-EDM-ROUTE-SUM

    grouping OSPFV3-EDM-FLOOD-LIST {
      description
        "OSPFv3 flood list information";
      leaf ls-transmission-timer {
        type uint32;
        description
          "Time until next LS transmission (ms) ";
      }

      leaf queue-length {
        type uint32;
        description
          "Number of LSAs currently being flooded ";
      }

      list link-flood {
        description "Link floodlist";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list link-flood

      list area-flood {
        description "Area scope floodlist";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list area-flood

      list as-flood {
        description "AS scope floodlist";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list as-flood
    }  // grouping OSPFV3-EDM-FLOOD-LIST

    grouping OSPFV3-EDM-LSA-SUM {
      description "LSA summary entry";
      leaf header-lsa-type {
        type Ospfv3-lsa1;
        description "LSA type";
      }

      leaf header-lsa-age {
        type uint16;
        units "second";
        description
          "Age of the LSA (seconds)";
      }

      leaf header-lsa-id {
        type inet:ipv4-address;
        description "LSA ID";
      }

      leaf header-advertising-router {
        type inet:ipv4-address;
        description
          "Router ID of the advertising router";
      }

      leaf header-sequence-number {
        type uint32;
        description
          "Current LSA sequence number";
      }

      leaf header-lsa-checksum {
        type uint16;
        description "Checksum of the LSA";
      }
    }  // grouping OSPFV3-EDM-LSA-SUM

    grouping OSPFV3-EDM-REQUEST {
      description
        "OSPFv3 request list information";
      leaf request-neighbor-address {
        type inet:ipv6-address;
        description "Neighbor IP address";
      }

      leaf is-request-virtual-link {
        type boolean;
        description
          "Whether the request list is to be sent over a
         virtual link";
      }

      leaf request-virtual-link-id {
        type uint32;
        description
          "Virtual link ID in case it is a virtual link";
      }

      leaf is-request-sham-link {
        type boolean;
        description
          "Whether the request list is to be sent over a
         sham link";
      }

      leaf request-sham-link-id {
        type uint32;
        description
          "Sham link ID in case it is a sham link";
      }

      list request {
        description
          "List of request list entries";
        uses OSPFV3-EDM-LSA-SUM;
      }  // list request
    }  // grouping OSPFV3-EDM-REQUEST

    grouping OSPFV3-SH-ROUTE-EXTENDED-COMM {
      description
        "OSPF External Route Extended Community
       Information";
      leaf extended-community-domain-id-value {
        type yang:hex-string;
        description "Domain ID value";
      }

      leaf extended-communityl-domain-id-type {
        type uint16;
        description "Domain ID type";
      }

      leaf extended-community-area-id {
        type uint32;
        description "Area id";
      }

      leaf extended-community-router-id {
        type inet:ipv4-address;
        description "Router id";
      }

      leaf extended-community-route-type {
        type uint8;
        description "Route type";
      }

      leaf extended-community-options {
        type uint8;
        description "Route Options";
      }
    }  // grouping OSPFV3-SH-ROUTE-EXTENDED-COMM

    grouping OSPFV3-SH-NNH-INFO {
      description
        "OSPF Neighbor NextHop Information";
      leaf neighbor-next-hop-intf-index {
        type uint32;
        description
          "Neighbor NextHop Interface Index";
      }
    }  // grouping OSPFV3-SH-NNH-INFO

    grouping OSPFV3-SH-BACKUP-PATH {
      description
        "OSPFv3 Route Backup Path Information";
      leaf backup-route-interface-name {
        type xr:Interface-name;
        description "Next hop Interface";
      }

      leaf backup-route-next-hop-address {
        type inet:ipv6-address;
        description "Nexthop IP address";
      }

      leaf backup-route-source {
        type inet:ipv4-address;
        description
          "IP address of source of route";
      }

      leaf backup-metric {
        type uint32;
        description "Metric";
      }

      leaf primary-path {
        type boolean;
        description
          "Whether this path is selected as primary path";
      }

      leaf line-card-disjoint {
        type boolean;
        description
          "Whether this path is Line Card Disjoint";
      }

      leaf downstream {
        type boolean;
        description
          "Whether this path is Downstream";
      }

      leaf node-protect {
        type boolean;
        description
          "Whether this path is Node Protecting";
      }

      leaf srlg-disjoint {
        type boolean;
        description
          "Whether this path is SRLG Disjoint";
      }
    }  // grouping OSPFV3-SH-BACKUP-PATH

    grouping OSPFV3-EDM-TOP-PATH {
      description
        "OSPFv3 topology path information";
      container route-backup-path {
        description "Backup Path Info";
        uses OSPFV3-SH-BACKUP-PATH;
      }  // container route-backup-path

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

      leaf interface-index {
        type uint32;
        description
          "Route path interface Index ";
      }

      leaf route-path-next-hop {
        type inet:ipv6-address;
        description "Next hop of this path";
      }

      leaf route-path-id {
        type uint16;
        description "Path ID of path";
      }

      list neighbor-next-hop {
        description "NeighborNextHop";
        uses OSPFV3-SH-NNH-INFO;
      }  // list neighbor-next-hop
    }  // grouping OSPFV3-EDM-TOP-PATH

    grouping OSPFV3-EDM-TOPOLOGY {
      description
        "OSPFv3 Topology Information";
      leaf route-id {
        type inet:ipv4-address;
        description "Route ID ";
      }

      leaf route-distance {
        type uint32;
        description "Route admin distance ";
      }

      leaf route-cost {
        type uint32;
        description "Route cost/metric ";
      }

      leaf route-type {
        type uint32;
        description "Type of route subtype";
      }
    }  // grouping OSPFV3-EDM-TOPOLOGY

    grouping OSPFV3-EDM-TOPOLOGY-EXTERNAL {
      description
        "OSPFv3 Topology External Information";
      container route-topology {
        description
          "Common Route topology information";
        uses OSPFV3-EDM-TOPOLOGY;
      }  // container route-topology

      container route-extended-community {
        description
          "Extended communities in the route";
        uses OSPFV3-SH-ROUTE-EXTENDED-COMM;
      }  // container route-extended-community

      list route-path {
        description
          "List of paths to this route";
        uses OSPFV3-EDM-TOP-PATH;
      }  // list route-path
    }  // grouping OSPFV3-EDM-TOPOLOGY-EXTERNAL

    grouping OSPFV3-EDM-REDIST {
      description
        "OSPFv3 Redistribution Information";
      leaf protocol-name-xr {
        type string {
          length "0..40";
        }
        description
          "Name of the protocol being redistributed";
      }

      leaf process-id {
        type string {
          length "0..40";
        }
        description "Process ID ";
      }

      leaf redist-metric-flag {
        type boolean;
        description
          "Redistribution metric flag";
      }

      leaf redist-metric {
        type uint32;
        description "Redistribution metric";
      }

      leaf redist-metric-type-flag {
        type boolean;
        description
          "Whether Redistribution Metric Type is configured";
      }

      leaf redist-metric-type {
        type uint8;
        description
          "Redistribution metric type";
      }

      leaf redist-tag {
        type uint32;
        description "Redistribution Tag";
      }

      leaf policy-name {
        type string;
        description "Route policy name ";
      }
    }  // grouping OSPFV3-EDM-REDIST

    grouping OSPFV3-EDM-INTERFACE-BFD {
      description
        "Interface BFD information";
      leaf bfd-intf-enable-mode {
        type uint32;
        description
          "BFD Enable Mode on the interface -
         Default/Strict";
      }

      leaf bfd-interval {
        type uint32;
        description "BFD interval (ms) ";
      }

      leaf bfd-detection-multiplier {
        type uint32;
        description
          "Detection multiplier value used by BFD";
      }
    }  // grouping OSPFV3-EDM-INTERFACE-BFD

    grouping OSPFV3-EDM-INTERFACE-UP {
      description
        "OSPFv3 interface up-only information";
      leaf wait-time {
        type uint32;
        description
          "Wait time for DR/BDR selection (s)";
      }

      leaf interface-area-flood-index {
        type uint32;
        description
          "Area scope LSAs flood index";
      }

      leaf interface-as-flood-index {
        type uint32;
        description
          "AS scope LSAs flood index ";
      }

      leaf interface-link-flood-index {
        type uint32;
        description
          "Interface flood link index ";
      }

      leaf flood-queue-length {
        type uint32;
        description
          "Length of the Flood queue";
      }

      leaf interface-area-next-flood {
        type uint32;
        description
          "Next LSA to flood (Area scope)";
      }

      leaf interface-area-next-flood-index {
        type uint32;
        description
          "Index of next LSA to flood (Area scope) ";
      }

      leaf interface-as-next-flood {
        type uint32;
        description
          "Next LSA to flood (AS scope)";
      }

      leaf interface-as-next-flood-index {
        type uint32;
        description
          "Index of next LSA to flood (AS scope)";
      }

      leaf interface-link-next-flood {
        type uint32;
        description
          "Interface link next flood information ";
      }

      leaf interface-link-next-index {
        type uint32;
        description
          "Interface link next information index ";
      }

      leaf flood-scan-length {
        type uint32;
        description
          "Number of LSAs in the last update packet";
      }

      leaf maximum-flood-length {
        type uint32;
        description
          "Maximum number of LSAs sent in an update packet
         till now";
      }

      leaf last-flood-time {
        type uint32;
        description
          "Time taken for last flooding (ms)";
      }

      leaf maximum-flood-time {
        type uint32;
        description
          "Maximum time taken for flooding (ms) till now";
      }

      leaf interface-flood-pacing-timer {
        type uint32;
        description
          "Time until next flood pacing timer (ms) ";
      }

      leaf interface-neighbors {
        type uint16;
        description
          "Total number of neighbors ";
      }

      leaf suppressed-hellos {
        type uint16;
        description
          "Number of neighbors for which hellos are
         suppressed ";
      }
    }  // grouping OSPFV3-EDM-INTERFACE-UP

    grouping OSPFV3-EDM-INTERFACE-NBR {
      description
        "OSPFv3 interface neighbor information";
      leaf interface-neighbor-id {
        type inet:ipv4-address;
        description "Neighbor router ID ";
      }

      leaf interface-neighbor-cost {
        type uint32;
        description
          "Cost of link to neighbor";
      }

      leaf is-neighbor-dr {
        type boolean;
        description
          "If true, designated router is found ";
      }

      leaf is-neighbor-bdr {
        type boolean;
        description
          "If true, backup designated router is found ";
      }

      leaf is-hello-suppressed {
        type boolean;
        description
          "If true, hello is suppressed ";
      }
    }  // grouping OSPFV3-EDM-INTERFACE-NBR

    grouping OSPFV3-EDM-INTERFACE {
      description
        "OSPFv3 interface information";
      container active-interface {
        description
          "Active interface details ";
        uses OSPFV3-EDM-INTERFACE-UP;
      }  // container active-interface

      container interface-bfd {
        description "BFD information ";
        uses OSPFV3-EDM-INTERFACE-BFD;
      }  // container interface-bfd

      leaf interface-state {
        type Im-state-enum;
        description "State of the interface";
      }

      leaf is-interface-line-up {
        type boolean;
        description
          "If true, line protocol is up ";
      }

      leaf is-interface-ip-security-required {
        type boolean;
        description
          "If true, interface IP security is required ";
      }

      leaf is-interface-ip-security-active {
        type boolean;
        description
          "If true, interface IP security is active ";
      }

      leaf interface-address {
        type inet:ipv6-address;
        description
          "IPv6 address of the Interface";
      }

      leaf interface-number {
        type uint32;
        description
          "Interface ifindex number ";
      }

      leaf interface-router-id {
        type inet:ipv4-address;
        description "Self router ID ";
      }

      leaf network-type {
        type Ospfv3-interface;
        description
          "OSPF Network type of the interface";
      }

      leaf interface-link-cost {
        type uint16;
        description
          "Link cost/metric of this Interface";
      }

      leaf is-interface-flood-reduction {
        type boolean;
        description
          "If true, interface flood reduction is active ";
      }

      leaf is-demand-circuit-configured {
        type boolean;
        description
          "If true, configured as demand circuit ";
      }

      leaf is-interface-demand-circuit {
        type boolean;
        description
          "If true, interface running as demand circuit";
      }

      leaf interface-dc-bitless-ls-as {
        type uint32;
        description
          "Number of LSAs with demand circuit bit not set
         for the area in which the interface is running";
      }

      leaf transmission-delay {
        type uint16;
        description
          "Interface transmission delay (sec)";
      }

      leaf ospf-interface-state {
        type Ospfv3-interface-state;
        description
          "OSPF IFSM state of this interface";
      }

      leaf interface-priority {
        type uint8;
        description
          "DR-priority of this interface";
      }

      leaf is-designated-router {
        type boolean;
        description
          "If true, this router is the designated router
         for this network";
      }

      leaf designated-router-id {
        type inet:ipv4-address;
        description
          "ID of the Designated router of this network";
      }

      leaf designated-router-address {
        type inet:ipv6-address;
        description
          "IPv6 address of the Designated router for this
         network";
      }

      leaf backup-designated-router-id {
        type inet:ipv4-address;
        description
          "ID of the Backup Designated router of this
         network";
      }

      leaf backup-designated-router-address {
        type inet:ipv6-address;
        description
          "IPv6 address of the Backup Designated router for
         this network";
      }

      leaf network-lsa-flush-timer {
        type uint32;
        units "second";
        description
          "The amount of time in seconds before flush timer
         for old network LSA expires ";
      }

      leaf is-interface-lsa-filtered {
        type boolean;
        description
          "Filter is configured for out going LSAs ";
      }

      leaf hello-interval {
        type uint32;
        description
          "Configured hello interval (s)";
      }

      leaf dead-interval {
        type uint32;
        description
          "Configured dead interval (s) ";
      }

      leaf wait-interval {
        type uint32;
        description
          "Configured wait interval (s) ";
      }

      leaf interface-retransmission-interval {
        type uint32;
        description
          "Configured retransmit interval (s) ";
      }

      leaf next-hello-time {
        type uint32;
        description
          "Time until next Hello (s) ";
      }

      leaf interface-authentication-spi {
        type uint32;
        description
          "Authentication Security Parameter Index for this
         interface";
      }

      leaf interface-authentication-transmit {
        type uint32;
        description
          "Interface authentication algorithm type ";
      }

      leaf is-interface-encryption-enabled {
        type boolean;
        description
          "Whether encryption is enabled for OSPF packets
         on this interface";
      }

      leaf is-prefix-suppress {
        type boolean;
        description
          "If true prefix suppression is enabled";
      }

      leaf interface-encryption-spi {
        type uint32;
        description
          "Encryption Security Parameter Index for this
         interface";
      }

      leaf interface-encryption-transmitted {
        type uint32;
        description
          "Interface encryption algorithm type used";
      }

      leaf interface-encrypted-authentication-transmitted {
        type uint32;
        description
          "Interface encrypted authentication algorithm
         type used";
      }

      leaf adjacent-neighbor {
        type uint32;
        description
          "Number of adjacent neighbors";
      }

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

      leaf configured-ldp-sync {
        type boolean;
        description
          "If true, configured as LDP sync";
      }

      leaf interface-ldp-sync {
        type boolean;
        description
          "If true, interface LDP sync is achieved";
      }

      leaf if-rib-l-csync-neede {
        type boolean;
        description "rib lc sync needed";
      }

      leaf if-rib-l-csync {
        type boolean;
        description "rib lc sync state";
      }

      leaf conditional-advertising-enabled {
        type boolean;
        description
          "If Conditional advertising based on route-policy
         is enabled";
      }

      leaf conditional-advertise-policy-name {
        type string;
        description
          "Name of the applied policy for Conditional
         advertising";
      }

      leaf conditional-advertising-result {
        type boolean;
        description
          "Result of the policy applied for Conditional
         advertising";
      }

      leaf interface-bandwidth {
        type uint32;
        description
          "Bandwidth of the Interface";
      }

      leaf ip-mtu {
        type uint16;
        description "IP MTU";
      }

      list interface-neighbor {
        description
          "Information for neighbors on the interface";
        uses OSPFV3-EDM-INTERFACE-NBR;
      }  // list interface-neighbor
    }  // grouping OSPFV3-EDM-INTERFACE

    grouping OSPFV3-EDM-NEIGHBOR-RETRANS {
      description
        "OSPFv3 neighbor retransmission information";
      leaf database-descriptor-retransmissions {
        type uint32;
        description
          "Number of database descriptor retransmissions
         during last exchange";
      }

      leaf area-flood-index {
        type uint32;
        description
          "Area scope LSA's flood index";
      }

      leaf as-flood-index {
        type uint32;
        description
          "AS scope LSA's flood index";
      }

      leaf link-flood-index {
        type uint32;
        description
          "Link scope LSA's flood index";
      }

      leaf neighbor-retransmissions {
        type uint32;
        description
          "Number of LSAs added to this neighbor's
         retransmit list";
      }

      leaf retransmissions {
        type uint32;
        description
          "Number of retransmission packets sent to this
         neighbor";
      }

      leaf area-first-flood {
        type uint32;
        description
          "First flood item for area scope LSAs";
      }

      leaf area-first-flood-index {
        type uint32;
        description
          "Index of the first flood item for area scope
         LSAs";
      }

      leaf as-first-flood {
        type uint32;
        description
          "First flood item for AS scope LSAs";
      }

      leaf as-first-flood-index {
        type uint32;
        description
          "Index for first flood item for AS scope LSAs";
      }

      leaf link-first-flood {
        type uint32;
        description
          "Link first flood information ";
      }

      leaf link-first-flood-index {
        type uint32;
        description
          "Link first flood information index";
      }

      leaf area-next-flood {
        type uint32;
        description
          "Next flood item for area scope LSAs";
      }

      leaf area-next-flood-index {
        type uint32;
        description
          "Index of next flood item for Area scope LSAs";
      }

      leaf as-next-flood {
        type uint32;
        description
          "Next flood item for AS scope LSAs";
      }

      leaf as-next-flood-index {
        type uint32;
        description
          "Index of next flood item for AS scope LSAs";
      }

      leaf link-next-flood {
        type uint32;
        description
          "Link next flood information ";
      }

      leaf link-next-flood-index {
        type uint32;
        description
          "Link next flood information index ";
      }

      leaf last-retransmission-length {
        type uint32;
        description
          "Number of LSAs sent in last retransmission";
      }

      leaf maximum-retransmission-length {
        type uint32;
        description
          "Maximum number of LSAs sent in a retransmission";
      }

      leaf last-retransmission-time {
        type uint32;
        description
          "Time taken for last retransmission (ms)";
      }

      leaf maximum-retransmission-time {
        type uint32;
        description
          "Maximum time taken for retransmission (ms) till
         now";
      }

      leaf lsa-retransmission-timer {
        type uint32;
        description
          "Time until next LSA retransmission (ms)";
      }
    }  // grouping OSPFV3-EDM-NEIGHBOR-RETRANS

    grouping OSPFV3-EDM-VLINK-NEIGHBOR {
      description
        "OSPFv3 virtual link neighbor information";
      container virtual-link-retransmission {
        description
          "Virtual link retransmission information ";
        uses OSPFV3-EDM-NEIGHBOR-RETRANS;
      }  // container virtual-link-retransmission

      leaf is-virtual-link-hello-suppressed {
        type boolean;
        description
          "If true, hello suppressed ";
      }

      leaf virtual-link-state {
        type Ospfv3-interface-state;
        description
          "OSPF interface state for the virtual link";
      }
    }  // grouping OSPFV3-EDM-VLINK-NEIGHBOR

    grouping OSPFV3-EDM-VIRTUAL-LINKS {
      description
        "OSPFv3 virtual link information";
      container virtual-link-neighbor {
        description "Neighbor information ";
        uses OSPFV3-EDM-VLINK-NEIGHBOR;
      }  // container virtual-link-neighbor

      leaf virtual-link-neighbor-id {
        type inet:ipv4-address;
        description
          "Neighbor on other end of this virtual link";
      }

      leaf virtual-link-interface-number {
        type uint32;
        description
          "Interface number of the Virtual link";
      }

      leaf virtual-link-state {
        type Ospfv3-interface-state;
        description
          "OSPF interface state for the virtual link";
      }

      leaf is-virtual-link-ip-security-required {
        type boolean;
        description
          "If true, virtual link IP security is required ";
      }

      leaf is-virtual-link-ip-security-active {
        type boolean;
        description
          "If true, Virtual link IP security is active ";
      }

      leaf virtual-link-neighbor-address {
        type inet:ipv6-address;
        description
          "IPv6 address of the neighbor on this Virtual
         link";
      }

      leaf is-virtual-link-demand-circuit {
        type boolean;
        description
          "If true, the link runs as demand circuit";
      }

      leaf virtual-link-dc-bitless-lsa {
        type uint32;
        description
          "Number of LSA's with demand circuit bit not set ";
      }

      leaf transit-area-id {
        type string;
        description
          "Area id of the transit area";
      }

      leaf interface-name {
        type xr:Interface-name;
        description
          "Interface on which this virtual link is formed";
      }

      leaf virtual-link-cost {
        type uint16;
        description
          "Cost of the virtual link";
      }

      leaf virual-link-transmission-delay {
        type uint16;
        units "second";
        description
          "Transmission delay in seconds";
      }

      leaf virtual-link-hello-interval {
        type uint32;
        description "Hello interval (s)";
      }

      leaf virtual-link-dead-interval {
        type uint32;
        description "Dead interval (s)";
      }

      leaf virtual-link-wait-interval {
        type uint32;
        description "Wait interval (s)";
      }

      leaf virtual-link-retransmission-interval {
        type uint32;
        description
          "Retransmission interval (s)";
      }

      leaf virtual-link-next-hello {
        type uint32;
        description
          "Time until next hello (s)";
      }

      leaf is-virtual-link-passive {
        type boolean;
        description
          "If true, interface is passive";
      }

      leaf is-virtual-link-authentication-enabled {
        type boolean;
        description
          "If true, authentication is enabled for this
         virtual link";
      }

      leaf virtual-link-authentication-spi {
        type uint32;
        description
          "Authentication Security Parameter Index for this
         virtual link";
      }

      leaf virtual-link-authentication-transmit {
        type uint32;
        description
          "Authentication algorithm for this virtual link";
      }

      leaf is-virtual-link-encryption-enabled {
        type boolean;
        description
          "If true, encryption is enabled for this virtual
         link ";
      }

      leaf virtual-link-encryption-spi {
        type uint32;
        description
          "Encryption Security Parameter Index for this
         virtual link";
      }

      leaf virtual-link-encryption-transmitted {
        type uint32;
        description
          "Encryption algorithm for this virtual link";
      }

      leaf virtual-link-encrypted-authentication-transmitted {
        type uint32;
        description
          "Encrypted authentication algorithm for this
         virtual link";
      }
    }  // grouping OSPFV3-EDM-VIRTUAL-LINKS

    grouping OSPFV3-EDM-LSA-UNKNOWN {
      description
        "OSPFv3 Unknown LSA Database Information";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

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

      leaf is-virtual-link {
        type boolean;
        description
          "If true, it is a virtual link ";
      }

      leaf virtual-link-id {
        type uint32;
        description
          "virtual link ID if it is a virtual link";
      }

      leaf is-sham-link {
        type boolean;
        description
          "If true, it is a sham link ";
      }

      leaf sham-link-id {
        type uint32;
        description "Shamlink ID ";
      }
    }  // grouping OSPFV3-EDM-LSA-UNKNOWN

    grouping OSPFV3-EDM-LSA-GRACE {
      description "OSPFv3 Grace LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

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

      leaf is-virtual-link {
        type boolean;
        description
          "If true, it is a virtual link";
      }

      leaf virtual-link-id {
        type uint32;
        description
          "virtual link ID if it is a virtual link";
      }

      leaf is-sham-link {
        type boolean;
        description
          "If true, it is a sham link";
      }

      leaf sham-link-id {
        type uint32;
        description
          "Sham link ID if it is a sham link";
      }

      leaf grace-period {
        type uint32;
        description
          "The grace periord where helper routers should
         wait before advertising it fully adjacent(s) ";
      }

      leaf grace-reason {
        type Ospfv3-graceful-restart-reason;
        description
          "Reason for router restart";
      }
    }  // grouping OSPFV3-EDM-LSA-GRACE

    grouping OSPFV3-EDM-LSA-PREFIX {
      description "OSPFv3 Prefix LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      leaf reference-type {
        type Ospfv3-lsa1;
        description
          "Reference LSA type, whether Router or Network";
      }

      leaf reference-lsa-id {
        type uint32;
        description
          "LSA ID of the Reference LSA";
      }

      leaf reference-advertised-router {
        type inet:ipv4-address;
        description
          "Advertising Router ID of the Reference LSA";
      }

      list prefix {
        description "OSPFv3 prefix ";
        uses OSPFV3-EDM-PREFIX;
      }  // list prefix
    }  // grouping OSPFV3-EDM-LSA-PREFIX

    grouping OSPFV3-EDM-PREFIX {
      description "OSPFv3 Prefix Type";
      leaf prefix {
        type inet:ipv6-address;
        description "OSPFv3 prefix ";
      }

      leaf ospfv3-prefix-length {
        type uint8;
        description
          "OSPFv3 prefix length of the IPv6 prefix";
      }

      leaf ospfv3-prefix-options {
        type uint8;
        description
          "OSPFv3 prefix options in the LSA";
      }

      leaf ospfv3-prefix-metric {
        type uint16;
        description
          "OSPFv3 prefix metric/cost";
      }

      leaf priority {
        type Prefix-priority;
        description "Prefix priority";
      }
    }  // grouping OSPFV3-EDM-PREFIX

    grouping OSPFV3-EDM-LSA-LINK {
      description "OSPFv3 Link LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

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

      leaf is-virtual-link {
        type boolean;
        description
          "If true, it is a virtual link";
      }

      leaf virtual-link-id {
        type uint32;
        description
          "virtual link ID if it is a virtual link";
      }

      leaf is-sham-link {
        type boolean;
        description
          "If true, it is a sham link";
      }

      leaf sham-link-id {
        type uint32;
        description
          "Sham link ID if it is a sham link";
      }

      leaf lsa-link-local {
        type inet:ipv6-address;
        description "Link local address";
      }

      leaf router-priority {
        type uint8;
        description
          "Router priority on this link";
      }

      list prefix {
        description "OSPFv3 prefix ";
        uses OSPFV3-EDM-PREFIX;
      }  // list prefix
    }  // grouping OSPFV3-EDM-LSA-LINK

    grouping OSPFV3-EDM-LSA-EXTERNAL {
      description "OSPFv3 External LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA Information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      leaf prefix {
        type inet:ipv6-address;
        description "IPV6 address prefix ";
      }

      leaf prefix-length {
        type uint8;
        description
          "Prefix length of the IPv6 address";
      }

      leaf metric-type {
        type Ospfv3-default-metric;
        description
          "Metric type, whether Type 1 or Type 2";
      }

      leaf tos-cost {
        type uint32;
        description
          "Type of service cost metric ";
      }

      leaf is-forwarding-address-set {
        type boolean;
        description
          "If true, forwarding address is set ";
      }

      leaf forwarding-address {
        type inet:ipv6-address;
        description
          "Forwarding Address of the external prefix";
      }

      leaf external-tag {
        type uint32;
        description "Route Tag";
      }

      leaf priority {
        type Prefix-priority;
        description "Prefix priority";
      }
    }  // grouping OSPFV3-EDM-LSA-EXTERNAL

    grouping OSPFV3-EDM-LSA-IARTR {
      description
        "OSPFv3 Inter-area Router LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      leaf lsa-router-id {
        type uint32;
        description "LSA router ID ";
      }
    }  // grouping OSPFV3-EDM-LSA-IARTR

    grouping OSPFV3-EDM-LSA-IAPFX {
      description
        "OSPFv3 Inter-area Prefix LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA Information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      leaf prefix {
        type inet:ipv6-address;
        description "LSA address prefix ";
      }

      leaf prefix-length {
        type uint8;
        description
          "Prefix length of the IPv6 address";
      }

      leaf priority {
        type Prefix-priority;
        description "Prefix priority";
      }
    }  // grouping OSPFV3-EDM-LSA-IAPFX

    grouping OSPFV3-EDM-LSA-NETWORK {
      description "OSPFv3 Network LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      list neighbor-router {
        description "Neighbor router list";
        leaf entry {
          type inet:ipv4-address;
          description "Neighbor router list";
        }
      }  // list neighbor-router
    }  // grouping OSPFV3-EDM-LSA-NETWORK

    grouping OSPFV3-EDM-RPF-PATH {
      description
        "OSPFv3 Router LSA Reverse-Path Forwarding
       Information";
      leaf rpf-multicast-next-hop {
        type uint32;
        description
          "Next hop for Reverse Path Forwarding Multicast";
      }

      leaf interface-name {
        type xr:Interface-name;
        description
          "Reverse Path Forwarding Multicast IDB ";
      }
    }  // grouping OSPFV3-EDM-RPF-PATH

    grouping OSPFV3-EDM-LINK {
      description "OSPFv3 Router LSA Links";
      leaf link-type {
        type Ospfv3-link;
        description "Type of link";
      }

      leaf link-metric {
        type uint16;
        description "LSA link metric/cost ";
      }

      leaf link-interface-id {
        type uint32;
        description "LSA link interface ID ";
      }

      leaf link-neighbor-interface-id {
        type uint32;
        description
          "interface ID of the neighbor";
      }

      leaf link-neighbor-router-id {
        type inet:ipv4-address;
        description
          "Router id of the neighbor";
      }
    }  // grouping OSPFV3-EDM-LINK

    grouping OSPFV3-EDM-LSA-ROUTER {
      description "OSPFv3 Router LSA";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      container rpf-path {
        description
          "Router LSA Reverse-Path Forwarding information ";
        uses OSPFV3-EDM-RPF-PATH;
      }  // container rpf-path

      leaf router-la-bits {
        type uint8;
        description
          "Router LA bits in the format V/E/B where V bit
         is set for virtual link endpoint, E bit for ASBR
         and B bit for ABR";
      }

      list link {
        description
          "List of links in this LSA";
        uses OSPFV3-EDM-LINK;
      }  // list link
    }  // grouping OSPFV3-EDM-LSA-ROUTER

    grouping OSPFV3-EDM-DB-DETAIL {
      description
        "OSPFv3 Detailed LSA Database Information";
      leaf second-table-index {
        type uint8;
        units "second";
        description
          "Table index for Seconds";
      }

      leaf minute-table-index {
        type uint8;
        units "minute";
        description
          "Table index for Minutes";
      }

      leaf free-time {
        type uint32;
        description
          "The amount of time since the last check was made
         to free this LSA (s)";
      }

      leaf is-deleted {
        type boolean;
        description
          "If true, flag is set to delete this LSA ";
      }

      leaf is-routing-bit {
        type boolean;
        description
          "If true, Routing Bit set on the LSA";
      }

      leaf is-advertising-router-reachable {
        type boolean;
        description
          "If true, Advertising Router is reachable";
      }

      leaf is-no-delete {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because delete flag not set on this LSA";
      }

      leaf is-neighbor-exchange {
        type boolean;
        description
          "If true, the reason  not to delete this LSA is
         because neighbor is in exchange state";
      }

      leaf is-routing-table {
        type boolean;
        description
          "If true, the reason  not to delete this LSA is
         because it has a contributing entry in the
         routing table ";
      }

      leaf is-acknowledged {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because it's Acknowledgement list is not empty ";
      }

      leaf is-maximum-aged {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because it is in Maxage Queue";
      }

      leaf is-partial-spf {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because it is in partial SPF queue";
      }

      leaf is-flood-pending {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because waiting for flooding or retransmission";
      }

      leaf rate-limit {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because waiting for next wait-interval to expire";
      }

      leaf is-nsr-ack-pending {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because NSR ACK from standby is pending";
      }

      leaf nsr-flood-required {
        type boolean;
        description
          "If true, the reason not to delete this LSA is
         because it is pending flooding on switchover";
      }

      leaf lsa-flood-required-post-fail-over {
        type boolean;
        description
          "LSA flood required after FO";
      }

      leaf lsa-length {
        type uint16;
        description "Length of the LSA";
      }

      leaf lsa-sync-state {
        type Ospf-lsa-sync-state;
        description
          "State of LSA sync with active";
      }
    }  // grouping OSPFV3-EDM-DB-DETAIL

    grouping OSPFV3-EDM-DB-HEADER {
      description
        "OSPFv3 LSA Database Header";
      leaf lsa-type {
        type uint16;
        description "LSA type";
      }

      leaf lsa-area-id {
        type string {
          length "0..16";
        }
        description
          "Area ID in decimal or dotted-decimal format";
      }

      leaf lsa-age {
        type uint16;
        description "LSA's Age (s)";
      }

      leaf is-do-not-age-lsa {
        type boolean;
        description
          "If true, Do Not Age this LSA";
      }

      leaf ls-id {
        type uint32;
        description "LS ID";
      }

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

      leaf sequence-number {
        type uint32;
        description
          "Current Sequence number";
      }

      leaf checksum {
        type uint16;
        description "Checksum value";
      }

      leaf is-graceful-restart-active {
        type boolean;
        description
          "If true, if grace restart is active ";
      }
    }  // grouping OSPFV3-EDM-DB-HEADER

    grouping OSPFV3-EDM-DATABASE {
      description
        "OSPFv3 Database Information";
      container lsa-header {
        description "Header information ";
        uses OSPFV3-EDM-DB-HEADER;
      }  // container lsa-header

      container lsa-detail {
        description
          "Detailed LSA information";
        uses OSPFV3-EDM-DB-DETAIL;
      }  // container lsa-detail

      leaf links {
        type uint16;
        description "Number of links";
      }

      leaf router-la-bits {
        type uint8;
        description
          "Router LSA flags in the format V/E/B where V bit
         is set for virtual link endpoint, E bit for ASBR
         and B bit for ABR";
      }

      leaf reference-type {
        type uint16;
        description
          "Reference type of the LSA, if it is a prefix LSA";
      }

      leaf reference-lsa-id {
        type uint32;
        description
          "Reference LSA ID, if it is a prefix LSA";
      }

      leaf lsa-router-id {
        type uint32;
        description
          "Advertised router ID, if it is an inter area
         router LSA";
      }

      leaf prefix {
        type inet:ipv6-address;
        description "OSPFv3 address Prefix";
      }

      leaf prefix-length {
        type uint8;
        description
          "Prefix length, if it is a prefix LSA";
      }

      leaf interface-name {
        type xr:Interface-name;
        description
          "interface name, if it is a  link scope LSA";
      }

      leaf is-virtual-link {
        type boolean;
        description
          "If true, it is a virtual link";
      }

      leaf virtual-link-id {
        type uint32;
        description
          "virtual link ID if it is a virtual link";
      }

      leaf is-sham-link {
        type boolean;
        description
          "If true, it is a sham link";
      }

      leaf sham-link-id {
        type uint32;
        description
          "Sham link ID if it is a sham link";
      }
    }  // grouping OSPFV3-EDM-DATABASE

    grouping OSPFV3-LSA-INFO-UNION {
      description
        "Detail LSA information for an LSA";
      container lsa-summary-info {
        when
          "../lsa-info-type = 'mgmt-lsa-lsasum-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_LSASUM_TYPE'";
        }
        description
          "Summary information of LSAs";
        uses OSPFV3-EDM-DATABASE;
      }  // container lsa-summary-info

      container router-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-rtr-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_RTR_TYPE'";
        }
        description "Router LSA";
        uses OSPFV3-EDM-LSA-ROUTER;
      }  // container router-lsa-type

      container network-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-net-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_NET_TYPE'";
        }
        description "Network LSA";
        uses OSPFV3-EDM-LSA-NETWORK;
      }  // container network-lsa-type

      container inter-area-prefix-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-iapfx-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_IAPFX_TYPE'";
        }
        description "Inter Area Prefix LSA";
        uses OSPFV3-EDM-LSA-IAPFX;
      }  // container inter-area-prefix-lsa-type

      container inter-area-router-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-iartr-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_IARTR_TYPE'";
        }
        description "Inter Area Router LSA";
        uses OSPFV3-EDM-LSA-IARTR;
      }  // container inter-area-router-lsa-type

      container external-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-ext-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_EXT_TYPE'";
        }
        description "External LSA";
        uses OSPFV3-EDM-LSA-EXTERNAL;
      }  // container external-lsa-type

      container nssalsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-nssaext-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_NSSAEXT_TYPE'";
        }
        description "NSSA External LSA";
        uses OSPFV3-EDM-LSA-EXTERNAL;
      }  // container nssalsa-type

      container link-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-link-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_LINK_TYPE'";
        }
        description "Link LSA";
        uses OSPFV3-EDM-LSA-LINK;
      }  // container link-lsa-type

      container intra-area-prefix-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-prefix-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_PREFIX_TYPE'";
        }
        description "Intra Area Prefix LSA";
        uses OSPFV3-EDM-LSA-PREFIX;
      }  // container intra-area-prefix-lsa-type

      container grace-lsa {
        when
          "../lsa-info-type = 'mgmt-lsa-gr-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_GR_TYPE'";
        }
        description "Grace LSA";
        uses OSPFV3-EDM-LSA-GRACE;
      }  // container grace-lsa

      container unknown-link-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-unk-link-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_UNK_LINK_TYPE'";
        }
        description "Unknown Link Scope LSA";
        uses OSPFV3-EDM-LSA-UNKNOWN;
      }  // container unknown-link-lsa-type

      container unknown-area-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-unk-area-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_UNK_AREA_TYPE'";
        }
        description "Unknown-Area scope LSA";
        uses OSPFV3-EDM-LSA-UNKNOWN;
      }  // container unknown-area-lsa-type

      container unknown-aslsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-unk-as-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_UNK_AS_TYPE'";
        }
        description "Unknown-AS scope LSA";
        uses OSPFV3-EDM-LSA-UNKNOWN;
      }  // container unknown-aslsa-type

      container unknown-lsa-type {
        when
          "../lsa-info-type = 'mgmt-lsa-unk-type'" {
          description
            "../LSAInfoType = 'MGMT_LSA_UNK_TYPE'";
        }
        description "Unknown LSA";
        uses OSPFV3-EDM-LSA-UNKNOWN;
      }  // container unknown-lsa-type

      leaf lsa-info-type {
        type Ospfv3-lsa-info-types;
        description "LSAInfoType";
      }
    }  // grouping OSPFV3-LSA-INFO-UNION

    grouping OSPFV3-EDM-DATABASE-LSAINFO {
      description "OSPFv3 LSA Information";
      container lsa-info {
        description
          "Summary of all LSAs or LSA specific information ";
        uses OSPFV3-LSA-INFO-UNION;
      }  // container lsa-info
    }  // grouping OSPFV3-EDM-DATABASE-LSAINFO

    grouping OSPFV3-EDM-AREA-RANGE {
      description
        "OSPFv3 area range information";
      leaf range-prefix {
        type inet:ipv6-address;
        description
          "IP prefix for summarization";
      }

      leaf range-prefix-length {
        type uint32;
        description
          "IP prefix length for summarization";
      }

      leaf net-cost {
        type uint32;
        description "Prefix cost ";
      }

      leaf status {
        type Ospfv3-area-range-status;
        description "Area range status ";
      }

      leaf is-cost-configured {
        type boolean;
        description
          "If true, cost is configured ";
      }
    }  // grouping OSPFV3-EDM-AREA-RANGE

    grouping OSPFV3-EDM-AREA {
      description
        "OSPFv3 area summary information";
      leaf is-backbone-area-active {
        type boolean;
        description
          "If true, Backbone area is active";
      }

      leaf area-interfaces {
        type uint16;
        description
          "Number of interfaces in the area";
      }

      leaf is-area-stubbed {
        type boolean;
        description "If true, stub area";
      }

      leaf is-area-total-stubbed {
        type boolean;
        description
          "If true, totally stubby area";
      }

      leaf stub-default-cost {
        type uint32;
        description
          "Default cost for Stub or NSSA area";
      }

      leaf is-area-nssa {
        type boolean;
        description
          "If true, area is a NSSA";
      }

      leaf nssa-no-redistribution {
        type boolean;
        description
          "If true, No redistribution into this NSSA area";
      }

      leaf is-nssa-translated {
        type boolean;
        description
          "If true, perform 7/5 translation";
      }

      leaf is-nssa-translated-always {
        type boolean;
        description
          "If true, perform 7/5 translation always";
      }

      leaf is-nssa-default {
        type boolean;
        description
          "If true, generate NSSA default route";
      }

      leaf is-rrr-enabled {
        type boolean;
        description
          "If true, RRR is enabled";
      }

      leaf sp-fs {
        type uint32;
        description
          "Number of SPF calculations run";
      }

      leaf area-opaque-lsas {
        type uint32;
        description
          "Number of opaque LSAs in the area";
      }

      leaf area-opaque-lsa-checksum {
        type uint32;
        description
          "Sum of opaque LSA checksums";
      }

      leaf area-dc-bitless-ls-as {
        type uint32;
        description
          "Number of LSA with demand circuit bit not set";
      }

      leaf indication-ls-as {
        type uint32;
        description
          "Number of indication LSAs";
      }

      leaf do-not-age-ls-as {
        type uint32;
        description
          "Number of do not age LSAs";
      }

      leaf flood-list-length {
        type uint32;
        description
          "Number of LSAs which need to be flooded";
      }

      leaf area-lfa-interface-count {
        type uint32;
        description
          "Number of LFA enabled interfaces";
      }

      leaf area-per-prefix-lfa-interface-count {
        type uint32;
        description
          "Number of Per Prefix LFA enabled interfaces";
      }

      leaf area-lfa-revision {
        type uint32;
        description "Area LFA revision";
      }

      list area-range {
        description
          "List of ranges to summarize";
        uses OSPFV3-EDM-AREA-RANGE;
      }  // list area-range
    }  // grouping OSPFV3-EDM-AREA

    grouping OSPFV3-EDM-BR-PATH {
      description
        "OSPFv3 border router path";
      leaf is-intra-area-router {
        type boolean;
        description
          "If true, intra-area router else inter-area
         router";
      }

      leaf border-router-route-metric {
        type uint32;
        description "Metric";
      }

      leaf border-router-next-hop {
        type inet:ipv6-address;
        description "Next hop address ";
      }

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

      leaf border-router-type {
        type Ospfv3-border-route;
        description
          "Border router type, whether ABR or ASBR";
      }

      leaf border-router-area-id {
        type string {
          length "0..16";
        }
        description
          "Area string in decimal or dotted-decimal format ";
      }

      leaf spf-version {
        type uint32;
        description "SPF version";
      }
    }  // grouping OSPFV3-EDM-BR-PATH

    grouping OSPFV3-EDM-BORDER-ROUTER {
      description
        "OSPFv3 border router information";
      list border-router-path {
        description
          "List of border router paths";
        uses OSPFV3-EDM-BR-PATH;
      }  // list border-router-path
    }  // grouping OSPFV3-EDM-BORDER-ROUTER

    grouping OSPFV3-EDM-SUMMARY-PREFIX {
      description
        "OSPFv3 summary prefix information";
      leaf prefix-metric {
        type uint32;
        description
          "Metric value for the IPv6 prefix";
      }

      leaf prefix-metric-type {
        type Ospfv3-default-metric;
        description
          "Metric type of the prefix";
      }

      leaf tag {
        type uint32;
        description
          "Tag value of the prefix";
      }
    }  // grouping OSPFV3-EDM-SUMMARY-PREFIX
  }  // submodule Cisco-IOS-XR-ipv6-ospfv3-oper-sub1