submodule Cisco-IOS-XR-igp-topodb-oper-sub1 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-igp-topodb-oper {
        prefix
          Cisco-IOS-XR-igp-topodb-oper;
    }

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

    revision "2021-06-01" {
      description
        "Added changes to show if a FAD contains unknown parameters
       2020-10-20
         Modified for Flex algo Uloop support.
       2020-08-13
         Added task name ospf to restrict unlimited permission.
       2020-03-20
         Modified for Flex algo TILFA support.";
    }

    revision "2020-01-02" {
      description
        "Added topodb operational data support.";
    }

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

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

    semver:module-version "2.0.0";
    semver:module-version "1.1.0";
    semver:module-version "1.0.1";

    typedef Otlib-repair-el {
      type enumeration {
        enum "mgmt-otlib-repair-el-invalid" {
          value 0;
          description "Unknown LFA";
        }
        enum "mgmt-otlib-repair-el-p-node" {
          value 1;
          description "Direct LFA";
        }
        enum "mgmt-otlib-repair-el-q-node" {
          value 2;
          description "TI LFA";
        }
      }
      description "Otlib repair el";
    }

    typedef Otlib-lfa {
      type enumeration {
        enum "mgmt-otlib-unknown-lfa" {
          value 0;
          description "Unknown LFA";
        }
        enum "mgmt-otlib-direct-lfa" {
          value 1;
          description "Direct LFA";
        }
        enum "mgmt-otlib-ti-lfa" {
          value 2;
          description "TI LFA";
        }
      }
      description "Otlib lfa";
    }

    grouping OTLIB-SH-AREA-ALGO-SUMMARY {
      description "OTLIB Area Algo Summary";
      container uloop-timestamp-begin-last-successful-calc {
        description
          "Time at which last successful microloop
         calculation began";
        uses OTLIB-SHOW-TIME;
      }  // container uloop-timestamp-begin-last-successful-calc

      container uloop-timestamp-end-last-successful-calc {
        description
          "Time at which last successful microloop
         calculation was completed";
        uses OTLIB-SHOW-TIME;
      }  // container uloop-timestamp-end-last-successful-calc

      leaf algo-number {
        type uint8;
        description "Algo Number";
      }

      leaf spf-trigger-flags {
        type uint8;
        description "SPF Trigger Flags";
      }

      leaf spf-schedule-flags {
        type uint8;
        description "SPF Schedule Flags";
      }

      leaf spf-count {
        type uint8;
        description "SPF Count";
      }

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

      leaf fad-area-id-string {
        type string {
          length "0..16";
        }
        description
          "FAD Adv Router's Area ID";
      }

      leaf metric-type {
        type uint8;
        description "Metric Type";
      }

      leaf algo-type {
        type uint8;
        description "Algo Type";
      }

      leaf is-uloop-active {
        type boolean;
        description
          "Whether microloop avoidance is active";
      }

      leaf uloop-near-end-node {
        type uint32;
        description
          "Near end node in the active microloop
         calculation";
      }

      leaf uloop-far-end-node {
        type uint32;
        description
          "Far end node in the active microloop calculation";
      }

      leaf uloop-cost-in-out-node {
        type uint32;
        description
          "Node that had a cost in or cost out in the
         active microloop calculation";
      }

      leaf uloop-news {
        type uint8;
        description
          "Action that triggered the active microloop
         calculation";
      }

      leaf uloop-last-successful-near-end-node {
        type uint32;
        description
          "Near end node in the last successful microloop
         calculation";
      }

      leaf uloop-last-successful-far-end-node {
        type uint32;
        description
          "Far end node in the last successful microloop
         calculation";
      }

      leaf uloop-last-successful-cost-in-out-node {
        type uint32;
        description
          "Node that had a cost in or cost out in the last
         successful microloop calculation";
      }

      leaf uloop-last-successful-news {
        type uint8;
        description
          "Action that triggered the last successful
         microloop calculation";
      }

      leaf-list exclude-affinity {
        type uint32;
        description "Exclude Affinity";
      }

      leaf-list include-any-affinity {
        type uint32;
        description "Include Any Affinity";
      }

      leaf-list include-all-affinity {
        type uint32;
        description "Include All Affinity";
      }
    }  // grouping OTLIB-SH-AREA-ALGO-SUMMARY

    grouping OTLIB-SH-AREA-SUMMARY {
      description "OTLIB Area Summary";
      leaf area-id-string {
        type string {
          length "0..16";
        }
        description "Area ID";
      }

      leaf num-nodes {
        type uint16;
        description "No. of Nodes";
      }

      leaf ulooptime-remaining {
        type uint32;
        description
          "Time remaining for the active Microloop
         avoidance paths";
      }

      list algo {
        description "List of Algos";
        uses OTLIB-SH-AREA-ALGO-SUMMARY;
      }  // list algo
    }  // grouping OTLIB-SH-AREA-SUMMARY

    grouping OTLIB-SH-INST-SUMMARY {
      description "OTLIB Instance Summary";
      leaf vrf-name {
        type string;
        description "VRF Name";
      }

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

      leaf num-areas {
        type uint16;
        description "No. of Areas";
      }

      leaf spf-trigger-flags {
        type uint8;
        description "SPF Trigger Flags";
      }

      leaf spf-schedule-flags {
        type uint8;
        description "SPF Schedule Flags";
      }

      leaf num-algos {
        type uint8;
        description "No. of Algos supported";
      }

      leaf algo-status {
        type yang:hex-string;
        description "Algo Status";
      }

      leaf max-paths {
        type uint16;
        description "Max Paths";
      }

      leaf num-routes {
        type uint32;
        description "No. of Routes";
      }

      leaf-list route-work-queue-size {
        type uint32;
        max-elements 4;
        description "Route Work Queue Sizes";
      }

      list srgb {
        description "SRGB List";
        uses OTLIB-SHOW-SR-RANGE;
      }  // list srgb

      list area {
        description "List of Areas";
        uses OTLIB-SH-AREA-SUMMARY;
      }  // list area
    }  // grouping OTLIB-SH-INST-SUMMARY

    grouping OTLIB-SHOW-ROUTE-ULOOP-PATH {
      description
        "OTLIB Route Microloop Avoidance Path";
      leaf repair-list-size {
        type uint32;
        description "Repair List Size";
      }

      leaf tunnel-interface-name {
        type uint32;
        description
          "Microloop Avoidance Tunnel Interface";
      }

      list repair {
        max-elements 12;
        description
          "Microloop Avoidance Repair List";
        uses OTLIB-SH-REP-EL;
      }  // list repair
    }  // grouping OTLIB-SHOW-ROUTE-ULOOP-PATH

    grouping OTLIB-SH-REP-EL {
      description "OSPF Repair Element";
      leaf repair-element-id {
        type inet:ipv4-address;
        description
          "ID of the Repair Element";
      }

      leaf repair-label {
        type uint32;
        description
          "Label of Repair Element";
      }

      leaf repair-element-type {
        type Otlib-repair-el;
        description
          "Type of the Repair Element";
      }
    }  // grouping OTLIB-SH-REP-EL

    grouping OTLIB-SHOW-ROUTE-BACKUP-PATH {
      description "OTLIB Route Backup Path";
      leaf interface-handle {
        type uint32;
        description "Interface Handle";
      }

      leaf next-hop-address {
        type inet:ipv4-address;
        description "NextHop IP Address";
      }

      leaf neighbor-id {
        type inet:ipv4-address;
        description "Neighbor ID";
      }

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

      leaf backup-metric {
        type uint64;
        description "Backup Metric";
      }

      leaf primary-path {
        type boolean;
        description
          "Whether this is also a Primary Path";
      }

      leaf interface-disjoint {
        type boolean;
        description
          "Wheher this is a Interface Disjoint path";
      }

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

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

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

      leaf srlg-disjoint {
        type boolean;
        description
          "Whether this is a SRLG Disjoint path";
      }

      leaf weighted-srlg {
        type boolean;
        description
          "Whether this is a Weighted SRLG path";
      }

      leaf lfa-type {
        type Otlib-lfa;
        description "LFA type";
      }

      leaf backup-repair-list-size {
        type uint32;
        description "Repair List Size";
      }

      leaf backup-tunnel-interface-name {
        type uint32;
        description
          "Backup Tunnel Interface";
      }

      list backup-repair {
        max-elements 12;
        description "Backup Repair List";
        uses OTLIB-SH-REP-EL;
      }  // list backup-repair
    }  // grouping OTLIB-SHOW-ROUTE-BACKUP-PATH

    grouping OTLIB-SHOW-ROUTE-PATH {
      description "OTLIB Route Path";
      container backup-path {
        description "Backup path details";
        uses OTLIB-SHOW-ROUTE-BACKUP-PATH;
      }  // container backup-path

      container uloop-path {
        description
          "Microloop Avoidance Path";
        uses OTLIB-SHOW-ROUTE-ULOOP-PATH;
      }  // container uloop-path

      leaf next-hop-address {
        type inet:ipv4-address;
        description "NextHop IP Address";
      }

      leaf interface-handle {
        type uint32;
        description "Interface Handle";
      }

      leaf neighbor-id {
        type inet:ipv4-address;
        description "Neighbor ID";
      }

      leaf path-weight {
        type uint32;
        description "Path Weight";
      }

      leaf path-label {
        type uint32;
        description "Path Label";
      }
    }  // grouping OTLIB-SHOW-ROUTE-PATH

    grouping OTLIB-SHOW-TIME {
      description
        "Time in seconds and nanoseconds";
      leaf second {
        type uint32;
        description "Second";
      }

      leaf nanosecond {
        type uint32;
        description "Nanosecond";
      }
    }  // grouping OTLIB-SHOW-TIME

    grouping OTLIB-SHOW-ROUTE-ALGO {
      description "OTLIB Route Algo";
      container route-update-time {
        description
          "Time at which this route was updated";
        uses OTLIB-SHOW-TIME;
      }  // container route-update-time

      leaf algo-number {
        type uint8;
        description "Algo Number";
      }

      leaf route-metric {
        type uint64;
        description "Route Metric";
      }

      leaf route-algo-flags {
        type uint8;
        description "Route algo flags";
      }

      leaf route-type {
        type uint8;
        description "Route Type";
      }

      leaf route-sid {
        type uint32;
        description "Route SID";
      }

      leaf route-label {
        type uint32;
        description "Route label";
      }

      leaf path-count {
        type uint32;
        description "Route path count";
      }

      list path {
        description "Algo Path List";
        uses OTLIB-SHOW-ROUTE-PATH;
      }  // list path

      list route-contributor {
        description
          "Route prefix contributors";
        uses OTLIB-SHOW-PREFIX-CONTRIB;
      }  // list route-contributor
    }  // grouping OTLIB-SHOW-ROUTE-ALGO

    grouping OTLIB-SHOW-ROUTE {
      description "OTLIB Route";
      leaf route-prefix {
        type inet:ipv4-address;
        description "Route Prefix Address";
      }

      leaf route-prefix-length {
        type uint8;
        description "Route Prefix Length";
      }

      leaf route-priority {
        type uint8;
        description "Route priority";
      }

      leaf route-flags {
        type uint16;
        description "Route flags";
      }

      list algo {
        description "Route Algo list";
        uses OTLIB-SHOW-ROUTE-ALGO;
      }  // list algo
    }  // grouping OTLIB-SHOW-ROUTE

    grouping OTLIB-SHOW-ROUTE-INSTANCE {
      description "OTLIB Route Instance";
      leaf vrf-name {
        type string;
        description "VRF Name";
      }

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

      leaf num-routes {
        type uint32;
        description "No. of routes";
      }

      list route {
        description "List of Routes";
        uses OTLIB-SHOW-ROUTE;
      }  // list route
    }  // grouping OTLIB-SHOW-ROUTE-INSTANCE

    grouping OTLIB-SHOW-TOPO-PATH {
      description "OTLIB Topo Path";
      leaf next-hop-address {
        type inet:ipv4-address;
        description "NextHop IP Address";
      }

      leaf interface-handle {
        type uint32;
        description "Interface Handle";
      }

      leaf neighbor-id {
        type inet:ipv4-address;
        description "Neighbor ID";
      }

      leaf path-weight {
        type uint32;
        description "Path Weight";
      }
    }  // grouping OTLIB-SHOW-TOPO-PATH

    grouping OTLIB-SHOW-NODE-ALGO {
      description "OTLIB Node Algo";
      leaf algo-number {
        type uint8;
        description "Algo Number";
      }

      leaf node-distance {
        type uint64;
        description "Node Distance";
      }

      leaf is-node-reachable {
        type boolean;
        description "Node reachable";
      }

      leaf is-direct-node {
        type boolean;
        description "Direct Node";
      }

      leaf is-path-dirty {
        type boolean;
        description "Node is dirty";
      }

      list path {
        description "Algo Path List";
        uses OTLIB-SHOW-TOPO-PATH;
      }  // list path
    }  // grouping OTLIB-SHOW-NODE-ALGO

    grouping OTLIB-SHOW-PATH-NODE {
      description "OTLIB Path Node";
      container node-id {
        description "Node ID";
        uses OTLIB-SHOW-NODE-ID;
      }  // container node-id

      leaf is-root-node {
        type boolean;
        description "Is root node";
      }

      leaf is-area-border-router {
        type boolean;
        description "Node is ABR";
      }

      leaf is-as-border-router {
        type boolean;
        description "Node is ASBR";
      }

      list algo {
        description "List of node Algos";
        uses OTLIB-SHOW-NODE-ALGO;
      }  // list algo
    }  // grouping OTLIB-SHOW-PATH-NODE

    grouping OTLIB-SHOW-PATH-AREA {
      description "OTLIB Path Area";
      leaf area-id-string {
        type string {
          length "0..16";
        }
        description "Area ID";
      }

      list node {
        description "List of Nodes";
        uses OTLIB-SHOW-PATH-NODE;
      }  // list node
    }  // grouping OTLIB-SHOW-PATH-AREA

    grouping OTLIB-SHOW-PATH-INSTANCE {
      description "OTLIB Path Instance";
      leaf vrf-name {
        type string;
        description "VRF Name";
      }

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

      list area {
        description "List of Areas";
        uses OTLIB-SHOW-PATH-AREA;
      }  // list area
    }  // grouping OTLIB-SHOW-PATH-INSTANCE

    grouping OTLIB-SHOW-FAD-DEFN {
      description "OTLIB FAD Definition";
      leaf algo-number {
        type uint8;
        description "Algo Number";
      }

      leaf metric-type {
        type uint8;
        description "Metric Type";
      }

      leaf algo-type {
        type uint8;
        description "Algo Type";
      }

      leaf priority {
        type uint8;
        description "Algo Priority";
      }

      leaf fad-oper-flags {
        type uint16;
        description "FAD Operational Flags";
      }

      leaf fad-has-unsupported-params {
        type boolean;
        description
          "The FAD defintion contains TLVs or Flags that
         are not supported by this node";
      }

      leaf-list exclude-affinity {
        type uint32;
        description "Exclude Affinity";
      }

      leaf-list include-any-affinity {
        type uint32;
        description "Include Any Affinity";
      }

      leaf-list include-all-affinity {
        type uint32;
        description "Include All Affinity";
      }
    }  // grouping OTLIB-SHOW-FAD-DEFN

    grouping OTLIB-SHOW-SR-RANGE {
      description "OTLIB SR Range";
      leaf range-start {
        type uint32;
        description "Range Start";
      }

      leaf range-size {
        type uint32;
        description "Range Size";
      }
    }  // grouping OTLIB-SHOW-SR-RANGE

    grouping OTLIB-SHOW-PREFIX-CONTRIB {
      description "OTLIB Prefix contributor";
      leaf algo {
        type uint8;
        description "Algo number";
      }

      leaf sid {
        type uint32;
        description "SID";
      }

      leaf total-metric {
        type uint64;
        description "Total metric";
      }

      leaf contrib-flags {
        type uint8;
        description
          "Prefix contributor flags";
      }

      leaf sid-flags {
        type uint8;
        description "SID flags";
      }
    }  // grouping OTLIB-SHOW-PREFIX-CONTRIB

    grouping OTLIB-SHOW-PREFIX {
      description "OTLIB Prefix";
      leaf prefix-address {
        type inet:ipv4-address;
        description "Prefix Address";
      }

      leaf prefix-length {
        type uint8;
        description "Prefix Length";
      }

      leaf prefix-metric {
        type uint32;
        description "Prefix metric";
      }

      leaf route-type {
        type uint32;
        description "Route Type";
      }

      list prefix-contributor {
        description "Prefix Contributors";
        uses OTLIB-SHOW-PREFIX-CONTRIB;
      }  // list prefix-contributor
    }  // grouping OTLIB-SHOW-PREFIX

    grouping OTLIB-SHOW-LINK-ASLA-ATTR {
      description "OTLIB ASLA Link Attrs";
      leaf srte-metric {
        type uint32;
        description "SR-TE Metric";
      }

      leaf min-delay {
        type uint32;
        description "Min Delay";
      }

      leaf-list ext-admin-group {
        type uint32;
        units "bit";
        description "Ext. Admin Group bits";
      }

      leaf-list srlg {
        type uint32;
        description "SRLG values";
      }
    }  // grouping OTLIB-SHOW-LINK-ASLA-ATTR

    grouping OTLIB-SHOW-LINK-ATTR {
      description "OTLIB Link Attrs";
      container flex-algo-asla-attrs {
        description
          "Flex Algo ASLA Attributes";
        uses OTLIB-SHOW-LINK-ASLA-ATTR;
      }  // container flex-algo-asla-attrs

      leaf lsid {
        type inet:ipv4-address;
        description "Ext Link LSA ID";
      }

      leaf local-interface-id {
        type uint32;
        description "Local Interface ID";
      }

      leaf remote-interface-id {
        type uint32;
        description "Remote Interface ID";
      }

      leaf remote-ipv4-address {
        type inet:ipv4-address;
        description "Remote IPv4 Address";
      }

      leaf max-bandwidth {
        type uint32;
        description "Max Bandwidth";
      }
    }  // grouping OTLIB-SHOW-LINK-ATTR

    grouping OTLIB-SHOW-LINK-ID {
      description "OTLIB Link ID";
      leaf link-id {
        type inet:ipv4-address;
        description "Link ID";
      }

      leaf link-data {
        type inet:ipv4-address;
        description "Link Data";
      }

      leaf link-type {
        type uint8;
        description "Link Type";
      }
    }  // grouping OTLIB-SHOW-LINK-ID

    grouping OTLIB-SHOW-LINK {
      description "OTLIB Link";
      container link-id {
        description "Link ID";
        uses OTLIB-SHOW-LINK-ID;
      }  // container link-id

      container remote-link-id {
        description "Remote Link ID";
        uses OTLIB-SHOW-LINK-ID;
      }  // container remote-link-id

      container link-attrs {
        description "Link Attributes";
        uses OTLIB-SHOW-LINK-ATTR;
      }  // container link-attrs

      leaf link-metric {
        type uint16;
        description "Link Metric";
      }

      leaf link-subnet-mask {
        type inet:ipv4-address;
        description "Link Subnet Mask";
      }

      leaf link-oper-flags {
        type uint16;
        description "Link Operational flags";
      }

      leaf is-router-lsa-contrib {
        type boolean;
        description
          "Is Router LSA Contributing";
      }

      leaf is-network-lsa-contrib {
        type boolean;
        description
          "Is Network LSA Contributing";
      }

      leaf is-ext-link-lsa-contrib {
        type boolean;
        description
          "Is Ext Link LSA Contributing";
      }
    }  // grouping OTLIB-SHOW-LINK

    grouping OTLIB-SHOW-NODE-ID {
      description "OTLIB Node ID";
      leaf adv-router-id {
        type inet:ipv4-address;
        description "Advertising Router ID";
      }

      leaf dr-identifier {
        type inet:ipv4-address;
        description "Node DR Identifier";
      }
    }  // grouping OTLIB-SHOW-NODE-ID

    grouping OTLIB-SHOW-NODE {
      description "OTLIB Node";
      container node-id {
        description "Node ID";
        uses OTLIB-SHOW-NODE-ID;
      }  // container node-id

      leaf num-links {
        type uint16;
        description "Number of Links";
      }

      leaf num-prefixes {
        type uint32;
        description "Number of prefixes";
      }

      leaf is-root-node {
        type boolean;
        description "Is root node";
      }

      leaf is-area-border-router {
        type boolean;
        description "Node is ABR";
      }

      leaf is-as-border-router {
        type boolean;
        description "Node is ASBR";
      }

      leaf node-oper-flags {
        type uint16;
        description "Node Operational flags";
      }

      leaf is-router-lsa-contrib {
        type boolean;
        description
          "Is Router LSA Contributing";
      }

      leaf is-network-lsa-contrib {
        type boolean;
        description
          "Is Network LSA Contributing";
      }

      leaf is-router-info-lsa-contrib {
        type boolean;
        description
          "Is Router Info LSA Contributing";
      }

      leaf-list node-algo {
        type uint8;
        description "Node algo support list";
      }

      list link {
        description "List of Links";
        uses OTLIB-SHOW-LINK;
      }  // list link

      list prefix {
        description "List of prefixes";
        uses OTLIB-SHOW-PREFIX;
      }  // list prefix

      list srgb {
        description "Node SRGB List";
        uses OTLIB-SHOW-SR-RANGE;
      }  // list srgb

      list fad {
        description
          "Flex Algo Definition List";
        uses OTLIB-SHOW-FAD-DEFN;
      }  // list fad
    }  // grouping OTLIB-SHOW-NODE

    grouping OTLIB-SHOW-AREA {
      description "OTLIB Area";
      leaf area-id-string {
        type string {
          length "0..16";
        }
        description "Area ID string";
      }

      leaf num-nodes {
        type uint16;
        description
          "No. of nodes under area";
      }

      list node {
        description "List of Nodes";
        uses OTLIB-SHOW-NODE;
      }  // list node
    }  // grouping OTLIB-SHOW-AREA

    grouping OTLIB-SHOW-INSTANCE {
      description "OTLIB Instance";
      leaf vrf-name {
        type string;
        description "VRF Name";
      }

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

      list area {
        description "List of Areas";
        uses OTLIB-SHOW-AREA;
      }  // list area
    }  // grouping OTLIB-SHOW-INSTANCE
  }  // submodule Cisco-IOS-XR-igp-topodb-oper-sub1