submodule Cisco-IOS-XR-fib-common-oper-sub4 {

    yang-version 1;

    belongs-to
      Cisco-IOS-XR-fib-common-oper {
        prefix
          Cisco-IOS-XR-fib-common-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 fib-common package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-12-02" {
      description
        "Adding per-object accounting.
       2020-10-20
         NBC documentation of CSCvu06764, CSCvv14573,CSCvv76648
       2020-05-26
         Update SRv6 Block Space naming convention
       2020-05-05
         changes related to treat SRv6 and SID as well-known when parsing XML for yang";
    }

    revision "2020-01-16" {
      description
        "NBC documentation of CSCvs27272,CSCvs22018,CSCvs45512
       2019-10-29
       Updated srv6 global bag";
    }

    revision "2019-09-27" {
      description "IOS XR 7.0.x revision.";
    }

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

    revision "2019-04-02" {
      description
        "Fixed schema descriptions.";
    }

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

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

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

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

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

    typedef Fib-mpls-llc-entry-bag {
      type enumeration {
        enum "fib-mpls-llc-bag-type-xc" {
          value 1;
          description
            "fib mpls llc bag type xc";
        }
        enum "fib-mpls-llc-bag-type-pfx" {
          value 2;
          description
            "fib mpls llc bag type pfx";
        }
        enum "fib-mpls-llc-bag-type-lsm" {
          value 3;
          description
            "fib mpls llc bag type lsm";
        }
        enum "fib-mpls-llc-bag-type-max" {
          value 4;
          description
            "fib mpls llc bag type max";
        }
      }
      description "Fib mpls llc entry bag";
    }

    typedef Ipv6-address {
      type inet:ipv6-address;
      description "IPV6 Address ";
    }

    typedef Mgmt-srv6-sid-fmt {
      type enumeration {
        enum "none" {
          value 0;
          description "No format";
        }
        enum "base" {
          value 1;
          description "Base Format";
        }
        enum "f3216" {
          value 2;
          description
            "Micro-segment F3216 Format";
        }
      }
      description "SRv6 SID Format Type";
    }

    typedef Srv6-op-mode {
      type enumeration {
        enum "none" {
          value 0;
          description "No mode";
        }
        enum "srv6-base" {
          value 1;
          description "SRv6 base";
        }
        enum "srv6-micro-segment" {
          value 2;
          description "SRv6 micro-segment";
        }
      }
      description "SRv6 operational mode";
    }

    typedef Fib-nhinfo-ext-bag {
      type enumeration {
        enum "replicated-nh-info" {
          value 0;
          description "Replicated NHINFO";
        }
        enum "shared-nh-info" {
          value 1;
          description "Shared NHINFO";
        }
        enum "tunnel-endpoint" {
          value 2;
          description "Tunnel Endpoint";
        }
      }
      description
        "FIB NHINFO extension type";
    }

    typedef Fib-bag-adj-pref {
      type enumeration {
        enum "unspecified" {
          value 0;
          description
            "Preference is unspecified";
        }
        enum "low" {
          value 1;
          description "Preference is low";
        }
        enum "high" {
          value 2;
          description "Preference is high";
        }
      }
      description "FIB adjacency preference";
    }

    typedef Fib-rpf-mode {
      type enumeration {
        enum "fib-rpf-mode-strict" {
          value 0;
          description "RPF mode strict";
        }
        enum "fib-rpf-mode-loose" {
          value 1;
          description "RPF mode loose";
        }
        enum "fib-rpf-mode-unknown" {
          value 2;
          description "RPF mode unknown";
        }
      }
      description "RPF mode types";
    }

    typedef Fibidb-oper {
      type enumeration {
        enum "fibidb-none" {
          value 0;
          description "fibidb none";
        }
        enum "fibidb-create" {
          value 1;
          description "fibidb create";
        }
        enum "fibidb-delete" {
          value 2;
          description "fibidb delete";
        }
        enum "fibidb-modify" {
          value 3;
          description "fibidb modify";
        }
        enum "fibidb-max" {
          value 4;
          description "fibidb max";
        }
      }
      description "Fibidb oper";
    }

    typedef Fib-sh-tbl-fib-ext-bag {
      type enumeration {
        enum "leaf-extension" {
          value 1;
          description "Leaf Extension";
        }
      }
      description "Fib sh tbl fib ext bag";
    }

    typedef Mgmt-srv6-endpoint {
      type enumeration {
        enum "unknown" {
          value 0;
          description
            "Unknown Endpoint type";
        }
        enum "end" {
          value 1;
          description "End (no PSP/USP)";
        }
        enum "end-with-psp" {
          value 2;
          description "End with PSP";
        }
        enum "end-with-usp" {
          value 3;
          description "End with USP";
        }
        enum "end-with-psp-usp" {
          value 4;
          description "End with PSP/USP";
        }
        enum "end-x" {
          value 5;
          description "End.X (no PSP/USP)";
        }
        enum "end-x-with-psp" {
          value 6;
          description "End.X with PSP";
        }
        enum "end-x-with-usp" {
          value 7;
          description "End.X with USP";
        }
        enum "end-x-with-psp-usp" {
          value 8;
          description "End.X with PSP/USP";
        }
        enum "end-tbl" {
          value 9;
          description "End.T (no PSP/USP)";
        }
        enum "end-tbl-with-psp" {
          value 10;
          description "End.T with PSP";
        }
        enum "end-tbl-with-usp" {
          value 11;
          description "End.T with USP";
        }
        enum "end-tbl-with-psp-usp" {
          value 12;
          description "End.T with PSP/USP";
        }
        enum "end-b6-insert" {
          value 13;
          description "End.B6.Insert";
        }
        enum "end-b6-encaps" {
          value 14;
          description "End.B6.Encaps";
        }
        enum "end-bm" {
          value 15;
          description "End.BM";
        }
        enum "end-dx6" {
          value 16;
          description "End.DX6";
        }
        enum "end-dx4" {
          value 17;
          description "End.DX4";
        }
        enum "end-dt6" {
          value 18;
          description "End.DT6";
        }
        enum "end-dt4" {
          value 19;
          description "End.DT4";
        }
        enum "end-dt46" {
          value 20;
          description "End.DT46";
        }
        enum "end-dx2" {
          value 21;
          description "End.DX2";
        }
        enum "end-dx2v" {
          value 22;
          description "End.DX2V";
        }
        enum "end-dt2u" {
          value 23;
          description "End.DT2U";
        }
        enum "end-dt2m" {
          value 24;
          description "End.DT2M";
        }
        enum "end-s" {
          value 25;
          description "End.S";
        }
        enum "end-b6-insert-red" {
          value 26;
          description
            "End.B6.Insert.Reduced";
        }
        enum "end-b6-encaps-red" {
          value 27;
          description
            "End.B6.Encaps.Reduced";
        }
        enum "end-with-usd" {
          value 28;
          description "End with USD";
        }
        enum "end-with-psp-usd" {
          value 29;
          description "End with PSP/USD";
        }
        enum "end-with-usp-usd" {
          value 30;
          description "End with USP/USD";
        }
        enum "end-with-psp-usp-usd" {
          value 31;
          description "End with PSP/USP/USD";
        }
        enum "end-x-with-usd" {
          value 32;
          description "End.X with USD";
        }
        enum "end-x-with-psp-usd" {
          value 33;
          description "End.X with PSP/USD";
        }
        enum "end-x-with-usp-usd" {
          value 34;
          description "End.X with USP/USD";
        }
        enum "end-x-with-psp-usp-usd" {
          value 35;
          description
            "End.X with PSP/USP/USD";
        }
        enum "end-tbl-with-usd" {
          value 36;
          description "End.T with USD";
        }
        enum "end-tbl-with-psp-usd" {
          value 37;
          description "End.T with PSP/USD";
        }
        enum "end-tbl-with-usp-usd" {
          value 38;
          description "End.T with USP/USD";
        }
        enum "end-tbl-with-psp-usp-usd" {
          value 39;
          description
            "End.T with PSP/USP/USD";
        }
        enum "end-op" {
          value 40;
          description "End.OP";
        }
        enum "end-otp" {
          value 41;
          description "End.OTP";
        }
        enum "un-shift-only" {
          value 42;
          description "uN Shift-only";
        }
        enum "un" {
          value 43;
          description "uN";
        }
        enum "un-psp" {
          value 44;
          description "uN with PSP";
        }
        enum "un-usp" {
          value 45;
          description "uN with USP";
        }
        enum "un-psp-usp" {
          value 46;
          description "uN with PSP-USP";
        }
        enum "un-usd" {
          value 47;
          description "uN with USD";
        }
        enum "un-psp-usd" {
          value 48;
          description "uN with PSP-USD";
        }
        enum "un-usp-usd" {
          value 49;
          description "uN with USP-USD";
        }
        enum "un-psp-usp-usd" {
          value 50;
          description "uN with PSP_USP-USD";
        }
        enum "ua-shift-only" {
          value 51;
          description "uA Shift-only";
        }
        enum "ua" {
          value 52;
          description "uA";
        }
        enum "ua-psp" {
          value 53;
          description "uA with PSP";
        }
        enum "ua-usp" {
          value 54;
          description "uA with USP";
        }
        enum "ua-psp-usp" {
          value 55;
          description "uA with PSP-USP";
        }
        enum "ua-usd" {
          value 56;
          description "uA with USD";
        }
        enum "ua-psp-usd" {
          value 57;
          description "uA with PSP-USD";
        }
        enum "ua-usp-usd" {
          value 58;
          description "uA with USP-USD";
        }
        enum "ua-psp-usp-usd" {
          value 59;
          description "uA with PSP_USP-USD";
        }
        enum "udx6" {
          value 60;
          description "uDX6";
        }
        enum "udx4" {
          value 61;
          description "uDX4";
        }
        enum "udt6" {
          value 62;
          description "uDT6";
        }
        enum "udt4" {
          value 63;
          description "uDT4";
        }
        enum "udt46" {
          value 64;
          description "uDT46";
        }
        enum "udx2" {
          value 65;
          description "uDX2";
        }
        enum "udx2v" {
          value 66;
          description "uDX2V";
        }
        enum "udt2u" {
          value 67;
          description "uDT2U";
        }
        enum "udt2m" {
          value 68;
          description "uDT2M";
        }
        enum "ub6-insert" {
          value 69;
          description "uB6 Insert";
        }
        enum "ub6-encaps" {
          value 70;
          description "uB6 Encaps";
        }
        enum "ub6-insert-red" {
          value 71;
          description "uB6 Insert.Red";
        }
        enum "ub6-encaps-red" {
          value 72;
          description "uB6 Encaps.Red";
        }
        enum "ubm" {
          value 73;
          description "uBM";
        }
      }
      description
        "SRv6 Endpoint Behavior Type";
    }

    typedef Fib-update-path-lfa-protection {
      type enumeration {
        enum "not-lfa-protected" {
          value 0;
          description "Not LFA-protected";
        }
        enum "protected" {
          value 1;
          description "Protected";
        }
        enum "local-lfa-backup" {
          value 2;
          description "Local-LFA backup";
        }
        enum "remote-lfa-backup" {
          value 3;
          description "Remote-LFA backup";
        }
        enum "ti-lfa-backup" {
          value 4;
          description "TI-LFA backup";
        }
      }
      description "LFA protection type";
    }

    typedef Fib-sh-ipencap-hdr {
      type enumeration {
        enum "fib-sh-ip-encap-none" {
          value 0;
          description "No Header";
        }
        enum "fib-sh-ip-encap-ip4" {
          value 1;
          description "IPv4 Header";
        }
        enum "fib-sh-ip-encap-ip6" {
          value 2;
          description "IPv6 Header";
        }
        enum "fib-sh-ip-encap-udp" {
          value 3;
          description "UDP Header";
        }
        enum "fib-sh-ip-encap-lisp" {
          value 4;
          description "Lisp Header";
        }
      }
      description "IP Encap Header Type";
    }

    typedef Fib-neh-special {
      type enumeration {
        enum "nh-not-found" {
          value 0;
          description "nh not found";
        }
        enum "nh-null0" {
          value 1;
          description "nh null0";
        }
        enum "nh-punt" {
          value 2;
          description "nh punt";
        }
        enum "nh-drop" {
          value 3;
          description "nh drop";
        }
        enum "nh-glean" {
          value 4;
          description "nh glean";
        }
        enum "nh-receive" {
          value 5;
          description "nh receive";
        }
        enum "nh-broadcast" {
          value 6;
          description "nh broadcast";
        }
        enum "nh-external" {
          value 7;
          description "nh external";
        }
        enum "nh-lisp" {
          value 8;
          description "nh lisp";
        }
        enum "nh-lookup" {
          value 9;
          description "nh lookup";
        }
        enum "nh-max-type" {
          value 10;
          description "nh max type";
        }
      }
      description "Fib neh special";
    }

    typedef Fib-neh {
      type enumeration {
        enum "nh-local" {
          value 0;
          description "nh local";
        }
        enum "nh-remote" {
          value 1;
          description "nh remote";
        }
        enum "nh-special" {
          value 2;
          description "nh special";
        }
      }
      description "Fib neh";
    }

    typedef Fib-adjacency-show {
      type enumeration {
        enum "fib-adjacency-normal" {
          value 0;
          description "Normal adjacency";
        }
        enum "fib-adjacency-null" {
          value 1;
          description "Null adjacency";
        }
        enum "fib-adjacency-punt" {
          value 2;
          description "Punt adjacency";
        }
        enum "fib-adjacency-drop" {
          value 3;
          description "Drop adjacency";
        }
        enum "fib-adjacency-glean" {
          value 4;
          description "Glean adjacency";
        }
        enum "fib-adjacency-discard" {
          value 5;
          description "Discard adjacency";
        }
        enum "fib-adjacency-broadcast" {
          value 6;
          description "Broadcast adjacency";
        }
        enum "fib-adjacency-external" {
          value 7;
          description "external adjacency";
        }
        enum "fib-adjacency-lisp" {
          value 8;
          description "LISP adjacency";
        }
        enum "fib-adjacency-unknown" {
          value 9;
          description "Unknown adjacency";
        }
      }
      description "Adjacency types";
    }

    typedef Fib-loadshare-show {
      type enumeration {
        enum "fib-load-share-none" {
          value 0;
          description "No loadsharing";
        }
        enum "fib-load-share-per-packet" {
          value 1;
          description
            "Per packet loadsharing";
        }
        enum "fib-load-share-dest-sharing" {
          value 2;
          description
            "Destination loadsharing";
        }
      }
      description "Loadsharing type";
    }

    typedef Fib-retry-entry-bag-sched-class {
      type enumeration {
        enum "slow" {
          value 0;
          description
            "Slow Scheduling Class";
        }
        enum "regular" {
          value 1;
          description
            "Regular Scheduling Class";
        }
        enum "fast" {
          value 2;
          description
            "Fast Scheduling Class";
        }
      }
      description
        "Fib retry entry bag sched class";
    }

    typedef Ss-lba-state {
      type enumeration {
        enum "l3" {
          value 0;
          description
            "L3 Load Balance config";
        }
        enum "l4" {
          value 1;
          description
            "L4 Load Balance config";
        }
      }
      description "Load Balance config";
    }

    typedef Fib-aib-adjacency {
      type enumeration {
        enum "tx-adjacency" {
          value 0;
          description "TX Adjacency";
        }
        enum "tx-vxlan-adjacency" {
          value 1;
          description "TX Vxlan Adjacency";
        }
        enum "tx-mpls-mcast-adjacency" {
          value 2;
          description
            "TX MPLS Mcast Adjacency";
        }
        enum "tx-subscriber-adjacency" {
          value 3;
          description
            "TX Subscriber Adjacency";
        }
        enum "rx-adjacency" {
          value 4;
          description "RX Adjacency";
        }
      }
      description "FIB AIB Adjacency type";
    }

    typedef Fib-bag-protocol {
      type enumeration {
        enum "ipv4" {
          value 0;
          description "IPv4 Protocol";
        }
        enum "ipv6" {
          value 1;
          description "IPv6 Protocol";
        }
        enum "mpls" {
          value 2;
          description "MPLS Protocol";
        }
      }
      description
        "Protocol definitions for FIB Bags";
    }

    typedef Fib-rsrc-mode-bag {
      type enumeration {
        enum "green" {
          value 0;
          description
            "Resource is in Green mode";
        }
        enum "yellow" {
          value 1;
          description
            "Resource is in Yellow mode";
        }
        enum "red" {
          value 2;
          description
            "Resource is in Red mode";
        }
      }
      description "FIB Resource Mode";
    }

    typedef Fib-bag-shmwin {
      type enumeration {
        enum "ipv4" {
          value 0;
          description
            "IPv4 Shared Memory Window";
        }
        enum "ipv6" {
          value 1;
          description
            "IPv6 Shared Memory Window";
        }
        enum "mpls" {
          value 2;
          description
            "MPLS Shared Memory Window";
        }
        enum "common" {
          value 3;
          description
            "Common Shared Memory Window";
        }
      }
      description
        "Shared Memory Window Type";
    }

    grouping FIB-MPLS-LLC-LSM {
      description "FIB MPLS LLC LSM";
      leaf nh {
        type string {
          length "0..52";
        }
        description "nh";
      }

      leaf mcast-id {
        type uint32;
        description "mcast id";
      }
    }  // grouping FIB-MPLS-LLC-LSM

    grouping FIB-MPLS-LLC-PFX {
      description "FIB MPLS LLC PFX";
      leaf pfx {
        type string {
          length "0..52";
        }
        description "pfx";
      }

      leaf tbl-id {
        type uint32;
        description "tbl id";
      }
    }  // grouping FIB-MPLS-LLC-PFX

    grouping FIB-MPLS-LLC-TYPE-EXT {
      description "FIB MPLS LLC TYPE EXT";
      container pfx {
        when
          "../type = 'fib-mpls-llc-bag-type-pfx'" {
          description
            "../type = 'FIB_MPLS_LLC_BAG_TYPE_PFX'";
        }
        description "pfx";
        uses FIB-MPLS-LLC-PFX;
      }  // container pfx

      container lsm {
        when
          "../type = 'fib-mpls-llc-bag-type-lsm'" {
          description
            "../type = 'FIB_MPLS_LLC_BAG_TYPE_LSM'";
        }
        description "lsm";
        uses FIB-MPLS-LLC-LSM;
      }  // container lsm

      leaf type {
        type Fib-mpls-llc-entry-bag;
        description "type";
      }
    }  // grouping FIB-MPLS-LLC-TYPE-EXT

    grouping FIB-MPLS-LLC {
      description "FIB MPLS LLC";
      container ext {
        description "ext";
        uses FIB-MPLS-LLC-TYPE-EXT;
      }  // container ext

      leaf local-label {
        type uint32;
        description "local label";
      }

      leaf source-xr {
        type uint32;
        description "source xr";
      }

      leaf update-ts {
        type uint64;
        description "update ts";
      }

      leaf retry-ts {
        type uint64;
        description "retry ts";
      }

      leaf num-retries {
        type uint32;
        description "num retries";
      }
    }  // grouping FIB-MPLS-LLC

    grouping FIB-OBJECT-QUEUE-ITEM-INFO {
      description
        "FIB Object Queue Information";
      container object-base {
        description "Object Base";
        uses FIB-SH-FIB-OBJ-BASE;
      }  // container object-base

      leaf key-string {
        type string;
        description "Object String Key";
      }
    }  // grouping FIB-OBJECT-QUEUE-ITEM-INFO

    grouping FIB-SH-PLAT-CAPABILITIES {
      description
        "FIB platform capabilities";
      leaf fpc-num-l3-lbl-levels {
        type uint8;
        description "L3 LBL levels";
      }

      leaf fpc-num-l3-lbl-paths {
        type uint8;
        description "L3 Hash buckets";
      }

      leaf fpc-num-l3-lbl-rec-paths {
        type uint8;
        description
          "L3 Recursive Hash buckets";
      }

      leaf fpc-num-l3-ucmp-paths {
        type uint8;
        description
          "L3 Unequal cost hash buckets";
      }

      leaf fpc-num-fwding-stages {
        type uint8;
        description "Forwarding stages";
      }

      leaf fpc-local-label-split {
        type uint32;
        description "Label split";
      }

      leaf fpc-stats-support {
        type boolean;
        description "Statistics support";
      }

      leaf fpc-platf-ready-cb-wait {
        type boolean;
        description "Plat ready cb register";
      }

      leaf fpc-num-paths-per-pbts-class {
        type uint8;
        description "Path per tunnel class";
      }

      leaf fpc-platf-v4-upd-disable {
        type boolean;
        description "V4 update disable";
      }

      leaf fpc-platf-v6-upd-disable {
        type boolean;
        description "V6 update disable";
      }

      leaf fpc-lba-tuples-default {
        type uint32;
        description "LBA tuples";
      }

      leaf fpc-mraps-support {
        type boolean;
        description "MRAPS support";
      }

      leaf fpc-pbts-defclass-support {
        type boolean;
        description
          "PBTS default class support";
      }

      leaf fpc-loadinfo-filter-support {
        type boolean;
        description
          "loadinfo filter support";
      }

      leaf fpc-nhid {
        type boolean;
        description "NHID support";
      }

      leaf fpc-platf-temp-back-walk-reqd {
        type boolean;
        description
          "Backwalk dependents is required";
      }

      leaf fpc-link-mpls-nhinfo-in-ipv6-thread-support {
        type boolean;
        description
          "Link MPLS IPv6 NH support";
      }

      leaf fpc-exclude-deag-bkup {
        type boolean;
        description
          "Exclude Deag backup Paths";
      }

      leaf fpc-dlb-support {
        type boolean;
        description
          "Per-destination load-balancing support";
      }

      leaf fpc-prefix-filter-support {
        type uint8;
        description
          "Prefix filter level of support";
      }

      leaf fpc-slowpath-ingress-inject-reqd {
        type boolean;
        description
          "Slowpath ingress inject required";
      }

      leaf fpc-cofo-support {
        type boolean;
        description "COFO supported";
      }

      leaf fpc-srv6-support {
        type boolean;
        description "SRv6 supported";
      }

      leaf fpc-srv6-replicated-lwldi-required {
        type boolean;
        description
          "SRv6 replicated LW-LDI required";
      }

      leaf fpc-v4v6-ldi-collapse-support {
        type boolean;
        description
          "IPv4 over IPV6 Collapse LDI support";
      }

      leaf fpc-1-pass-gre-support {
        type boolean;
        description "1-pass GRE support";
      }

      leaf fpc-srte-collapse-support {
        type boolean;
        description "SR-TE collapse support";
      }

      leaf fpc-eint-support {
        type boolean;
        description "EINT interface support";
      }

      leaf no-collapse-ip-over-mpls {
        type boolean;
        description
          "Disable collapse for IP routes over MPLS";
      }

      leaf encap-id-conflict {
        type boolean;
        description
          "Encap ID conflict Check";
      }

      leaf via-label-ignore-next-hop {
        type boolean;
        description
          "Ignore nexthop address and interface in case of
         via-label routes";
      }

      list fpc-lisp-decap-over-v4 {
        min-elements 3;
        max-elements 3;
        description "LISP Decap over 4";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list fpc-lisp-decap-over-v4

      list fpc-lisp-decap-over-v6 {
        min-elements 3;
        max-elements 3;
        description "LISP Decap over 6";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list fpc-lisp-decap-over-v6

      list fpc-lisp-ucmp {
        min-elements 3;
        max-elements 3;
        description "LISP UCMP support";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list fpc-lisp-ucmp

      list fpc-resolve-via-table {
        min-elements 3;
        max-elements 3;
        description "Fallback VRF support";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list fpc-resolve-via-table
    }  // grouping FIB-SH-PLAT-CAPABILITIES

    grouping FIB-SH-PROTO-FRR-STATS {
      description
        "FIB per protocol frr counters";
      leaf mi-num-intf-frr {
        type uint32;
        description
          "number of FRR events sent on nh interface down";
      }

      leaf mi-num-parent-intf-frr {
        type uint32;
        description
          "number of FRR events sent on nh parent interface
         down";
      }

      leaf mi-num-pfi-intf-down {
        type uint32;
        description
          "number of interface down FRR events from PFI";
      }

      leaf mi-num-bfd-down {
        type uint32;
        description
          "number of NH down FRR events frm BFD";
      }

      leaf mi-num-prot-frr-objects {
        type uint32;
        description
          "total number of prot FRR objects";
      }

      leaf mi-num-bkup-frr-objects {
        type uint32;
        description
          "total number of backup FRR objects";
      }

      leaf mi-num-tunid-allocs {
        type uint32;
        description
          "total number of successful FRR tunnel ID
         allocations";
      }

      leaf mi-num-tunid-alloc-failures {
        type uint32;
        description
          "total number of FRR tunnel ID allocation
         failures";
      }

      leaf mi-num-tunid-frees {
        type uint32;
        description
          "total number of successful FRR tunnel ID frees";
      }

      leaf mi-num-tunid-free-failures {
        type uint32;
        description
          "total number of FRR tunnel ID free failures";
      }

      leaf mi-num-frr-reset-queue-adds {
        type uint32;
        description
          "number of FRR reset queue adds";
      }

      leaf mi-num-frr-reset-queue-remove {
        type uint32;
        description
          "number of FRR reset queue deletes";
      }

      leaf mi-num-frr-reset {
        type uint32;
        description "number of FRR resets";
      }

      leaf mi-num-frr-proto-events {
        type uint32;
        description
          "number of frr events received in proto thread";
      }

      leaf mi-num-frr-logs {
        type uint32;
        description "frr log size";
      }
    }  // grouping FIB-SH-PROTO-FRR-STATS

    grouping ADDR-TYPE {
      description "Union for IPv4/Ipv6 addr";
      leaf afi {
        type int32;
        description "AFI";
      }

      leaf ipv4-address {
        when "../afi = '2'" {
          description "../AFI = '2'";
        }
        type inet:ipv4-address;
        description "IPV4 Address";
      }

      leaf ipv6-address {
        when "../afi = '10'" {
          description "../AFI = '10'";
        }
        type Ipv6-address;
        description "IPV6 Address";
      }
    }  // grouping ADDR-TYPE

    grouping FIB-SH-ROUTE-DEL-TS {
      description "FIB SH ROUTE DEL TS";
      container prfx {
        description "prfx";
        uses ADDR-TYPE;
      }  // container prfx

      leaf tableid {
        type uint32;
        description "tableid";
      }

      leaf prfx-len {
        type uint16;
        description "prfx len";
      }

      leaf prfx-proto {
        type uint16;
        description "prfx proto";
      }

      leaf msec-time {
        type uint64;
        description "msec time";
      }
    }  // grouping FIB-SH-ROUTE-DEL-TS

    grouping FIB-SH-PROTO-PURGE-STATS {
      description
        "FIB per protocol purge counters";
      list fpp-cntr {
        max-elements 3;
        description
          "the number of frees for this proto";
        leaf entry {
          type uint32;
          description
            "the number of frees for this proto";
        }
      }  // list fpp-cntr
    }  // grouping FIB-SH-PROTO-PURGE-STATS

    grouping FIB-SH-GTRIE-FN-TIMING {
      description
        "FIB timing statistics for individual gtrie
       functions";
      leaf fgft-fn {
        type string {
          length "0..64";
        }
        description "Gtrie operation";
      }

      leaf fgft-tot-updates {
        type uint64;
        description
          "Total number of updates";
      }

      leaf fgft-tot-updates-zero {
        type uint64;
        description
          "Total number of updates with zero timing (due to
         timestamp granularity)";
      }

      leaf fgft-tot-upd-time {
        type uint64;
        description "Total time for updates";
      }

      leaf fgft-max-time {
        type uint64;
        description "Time for the update";
      }

      leaf fgft-max-tstamp {
        type uint64;
        description
          "Time stamp of max update";
      }
    }  // grouping FIB-SH-GTRIE-FN-TIMING

    grouping FIB-SH-GTRIE-TIMING {
      description
        "FIB platform update statistics";
      leaf fgt-num-success {
        type uint64;
        description
          "Number of successful updates";
      }

      leaf fgt-num-failure {
        type uint64;
        description
          "Number of unsuccessful updates";
      }

      leaf fgt-upd-total-time {
        type uint64;
        description
          "Total time for all pd updates";
      }

      list fgt-gtrie-fn-timing {
        description
          "Array of max time info indexed by gtrie function";
        uses FIB-SH-GTRIE-FN-TIMING;
      }  // list fgt-gtrie-fn-timing
    }  // grouping FIB-SH-GTRIE-TIMING

    grouping FIB-SH-OBJ-ACTION-STATS {
      description
        "FIB Max time statistics for each action types of
       an object";
      leaf foas-tot-updates {
        type uint64;
        description
          "Total number of updates";
      }

      leaf foas-tot-upd-time {
        type uint64;
        description "Total time for updates";
      }

      leaf foas-tot-updates-zero {
        type uint64;
        description
          "Total number of updates that took zero time";
      }

      leaf foas-num-success {
        type uint64;
        description
          "Total number of successful updates";
      }

      leaf foas-num-failure {
        type uint64;
        description
          "Total number of failed updates";
      }

      leaf object-per-action-oor {
        type uint64;
        description
          "Total number of out of resource updates";
      }

      leaf foas-max-time {
        type uint64;
        description "Time for the update";
      }

      leaf foas-max-tstamp {
        type uint64;
        description
          "Time stamp of max update";
      }
    }  // grouping FIB-SH-OBJ-ACTION-STATS

    grouping FIB-SH-OBJ-STATS {
      description
        "FIB Max time statistics for each FIB object";
      leaf fos-tot-updates {
        type uint64;
        description
          "Total number of updates";
      }

      leaf fos-tot-upd-time {
        type uint64;
        description "Total time for updates";
      }

      leaf number-async-update-oor {
        type uint64;
        description
          "Number of asynchronous platform update out of
         resource";
      }

      leaf number-async-update-error {
        type uint64;
        description
          "Number of asynchronous platform update errors";
      }

      leaf number-async-oor-notify {
        type uint64;
        description
          "Number of asynchronous out of resource notify";
      }

      list fos-obj-act-stat {
        description
          "Array of max time info indexed by action type";
        uses FIB-SH-OBJ-ACTION-STATS;
      }  // list fos-obj-act-stat
    }  // grouping FIB-SH-OBJ-STATS

    grouping FIB-SH-PLATF-UPD-STATS {
      description
        "FIB platform update statistics";
      leaf fpus-num-success {
        type uint64;
        description
          "Number of successful updates";
      }

      leaf fpus-num-failure {
        type uint64;
        description
          "Number of unsuccessful updates";
      }

      leaf number-sync-update-oor {
        type uint64;
        description
          "Number of synchronous out of resources updates";
      }

      leaf number-async-update-oor {
        type uint64;
        description
          "Number of asynchronous out of resources updates";
      }

      leaf number-async-update-error {
        type uint64;
        description
          "Number of asynchronous update errors";
      }

      leaf number-async-oor-notify {
        type uint64;
        description
          "Number of asynchronous out of resources notify";
      }

      leaf fpus-upd-total-time {
        type uint64;
        description
          "Total time for all pd updates";
      }

      list fpus-obj-stat {
        description
          "Array of max time info indexed by object type";
        uses FIB-SH-OBJ-STATS;
      }  // list fpus-obj-stat
    }  // grouping FIB-SH-PLATF-UPD-STATS

    grouping FIB-SH-PROTO-DEBUG-STATS {
      description
        "FIB per protocol debug information";
      container fpd-platf-upd-stats {
        description
          "platform update statistics";
        uses FIB-SH-PLATF-UPD-STATS;
      }  // container fpd-platf-upd-stats

      container fpd-gtrie-timing {
        description
          "Gtrie timing statistics";
        uses FIB-SH-GTRIE-TIMING;
      }  // container fpd-gtrie-timing

      leaf fpd-gbltbl-entries {
        type uint64;
        description
          "the number of fib entries in global tbl";
      }

      leaf fpd-gbltbl-rej-entries {
        type uint64;
        description
          "the number of fib entries in global retry tbl";
      }

      leaf fpd-vrftbl-entries {
        type uint64;
        description
          "the number of fib entries in vrf tbls";
      }

      leaf fpd-vrftbl-rej-entries {
        type uint64;
        description
          "the number of fib entries in vrf retry tbls";
      }

      leaf fpd-num-tbls {
        type uint32;
        description
          "the number of tables in table set";
      }

      leaf fpd-bcdl-msgs {
        type uint64;
        description
          "the number of bcdl msgs";
      }

      leaf fpd-route-upd {
        type uint64;
        description
          "the number of route updates";
      }

      leaf fpd-route-del {
        type uint64;
        description
          "the number of route deletes";
      }

      leaf fpd-route-rcv {
        type uint64;
        description
          "the number of routes received";
      }

      leaf fpd-route-drops {
        type uint64;
        description
          "the number of routes dropped";
      }

      leaf fpd-lbl-recycled {
        type uint64;
        description
          "the number of routes handled with recycled label";
      }

      leaf fpd-version-mismatch-drops {
        type uint64;
        description
          "the number of routes dropped because of version
         mismatch";
      }

      leaf fpd-adj-upd {
        type uint64;
        description
          "the number of adjacency updates";
      }

      leaf fpd-adj-del {
        type uint64;
        description
          "the number of adjacency deletes";
      }

      leaf fpd-adj-upd-tx {
        type uint64;
        description
          "number of TX adjacency updates from AIB";
      }

      leaf fpd-adj-upd-tx-nh-found {
        type uint64;
        description
          "number of TX adjacency updates that found or
         created NH";
      }

      leaf fpd-adj-upd-tx-retry-created {
        type uint64;
        description
          "number of TX adjacency updates that went to
         retry";
      }

      leaf fpd-adj-tx-retry-nh-found {
        type uint64;
        description
          "number of TX adj retries that found or created
         NH";
      }

      leaf fpd-adj-tx-retry-obj-reinit {
        type uint64;
        description
          "number of times TX NH retry objects updated";
      }

      leaf fpd-adj-drops {
        type uint64;
        description
          " number of adj updates dropped because of OOR";
      }

      leaf fpd-adj-msg {
        type uint64;
        description "number of AIB messages";
      }

      leaf fpd-te-rcv {
        type uint64;
        description
          "the number of TE upds received";
      }

      leaf fpd-te-version-mismatch-drops {
        type uint64;
        description
          "the number of TE upds dropped because of version
         mismatch";
      }

      leaf fpd-num-retry-touts {
        type uint64;
        description
          "the number of retry timeouts";
      }

      leaf fpd-ldi-num-fixedup {
        type uint64;
        description
          "the number of fixup LDIs";
      }

      leaf fpd-ldi-num-correct-fixup {
        type uint64;
        description
          "the number of corrected fixup LDIs";
      }

      leaf fpd-pl-num-queued-fixedup {
        type uint64;
        description
          "the number of PL queued for fixup";
      }

      leaf fpd-pl-num-correct-fixup {
        type uint64;
        description
          "the number of corrected fixup PLs";
      }

      leaf fpd-pl-retry-add-exist {
        type uint64;
        description
          "the number PLs added to retry while already in
         retry";
      }

      leaf fpd-pl-inline-res-q {
        type uint64;
        description
          "the number of PLs linked to resolving tables for
         inline res";
      }

      leaf fpd-pl-with-backup-create-count {
        type uint64;
        description
          "number of pl creates with backu path";
      }

      leaf fpd-pl-with-backup-del-count {
        type uint64;
        description
          "number of pl deletes with backup path";
      }

      leaf fpd-pl-backup-enable-count {
        type uint64;
        description
          "number of PLs marked to include backup path";
      }

      leaf fpd-pl-backup-disable-count {
        type uint64;
        description
          " number of PLs unmarked to include backup path";
      }

      leaf fpd-pl-fast-nfn-count {
        type uint64;
        description
          "number of PLs visited on fast notification";
      }

      leaf fpd-ldi-backup-activate-count {
        type uint64;
        description
          "number of ldi backup path activications";
      }

      leaf fpd-ldi-last-backup-activate-time {
        type uint64;
        description
          "ldi mod time for last backup activation";
      }

      leaf fpd-ldi-max-backup-activate-time {
        type uint64;
        description
          "max ldi mod time for backup activation";
      }

      leaf fpd-ldi-min-backup-activate-time {
        type uint64;
        description
          "min ldi mod time for backup activation";
      }

      leaf fpd-ldi-total-backup-activate-time {
        type uint64;
        description
          "total ldi mod time for backup activation";
      }

      leaf fpd-ldi-avg-backup-activate-time {
        type uint64;
        description
          "avg ldi mod time for backup activation";
      }

      leaf fpd-recursion-constraint-count {
        type uint64;
        description
          "number of resolution failures because of
         recursion constraint";
      }

      leaf fpd-ldi-num-del-refcnt {
        type uint64;
        description
          "the number of deleted with non-zero refcount";
      }

      leaf fpd-retryq-size {
        type uint32;
        description
          "the number of elements in retryq";
      }

      leaf fpd-num-allocs {
        type uint64;
        description
          "the number of allocs for this proto";
      }

      leaf fpd-num-frees {
        type uint64;
        description
          "the number of frees for this proto";
      }

      leaf fpd-retryq-timeout {
        type uint32;
        description "timeout value in msec";
      }

      leaf fpd-retryq-sched-time {
        type uint32;
        description
          "Scheduler time period in msec";
      }

      list fpd-gbltbl-src-entry {
        max-elements 14;
        description
          "Number of global routes from
         
         each route source";
        leaf entry {
          type uint64;
          description
            "Number of global routes from
           
           each route source";
        }
      }  // list fpd-gbltbl-src-entry

      list fpd-vrftbl-src-entry {
        max-elements 14;
        description
          "Number of vrf routes from
         
         each route source";
        leaf entry {
          type uint64;
          description
            "Number of vrf routes from
           
           each route source";
        }
      }  // list fpd-vrftbl-src-entry

      list fpd-num-retry {
        description
          "the number of retries of each type";
        leaf entry {
          type uint64;
          description
            "the number of retries of each type";
        }
      }  // list fpd-num-retry
    }  // grouping FIB-SH-PROTO-DEBUG-STATS

    grouping FIB-SH-MISC {
      description "FIB miscellaneous info";
      container mi-issu-state {
        description "FIB ISSU state";
        uses FIB-ISSU-STATE;
      }  // container mi-issu-state

      container mi-plat-capabilities {
        description
          "FIB platform capabilities";
        uses FIB-SH-PLAT-CAPABILITIES;
      }  // container mi-plat-capabilities

      leaf mi-pfi-ifh-upd {
        type uint64;
        description
          "number of pfi ifh create notif";
      }

      leaf mi-pfi-ifh-del {
        type uint64;
        description
          "number of pfi ifh delete notif";
      }

      leaf mi-pfi-ifh-stale {
        type uint64;
        description
          "number of stale ifh removed";
      }

      leaf mi-tot-plat-upd-time {
        type uint64;
        description
          "total platform update time";
      }

      leaf mi-tot-gtrie-time {
        type uint64;
        description
          "total time spent in gtrie operations";
      }

      leaf mi-tot-dnld-time {
        type uint64;
        description "total download time";
      }

      leaf mi-clock-time {
        type uint64;
        description "clock download time";
      }

      leaf mi-cpu-time {
        type uint64;
        description "CPU download time";
      }

      leaf mi-shm-reset-ts {
        type uint64;
        description
          "Last FIB shared memory reset time stamp";
      }

      leaf mi-idb-recycle-count {
        type uint32;
        description
          "Number of idbs that hit ifh recycle";
      }

      leaf mi-idb-recycle-cleanup-count {
        type uint32;
        description
          "Number of idb cleaned up after hitting ifh
         recycle";
      }

      leaf mi-num-mgmt-list {
        type uint32;
        description
          "Number of management interfaces";
      }

      leaf mi-num-virtual-ll-addresses-added {
        type uint32;
        description
          "mi num virtual ll addresses added";
      }

      leaf mi-num-virtual-ll-addresses-deleted {
        type uint32;
        description
          "mi num virtual ll addresses deleted";
      }

      leaf mi-num-virtual-ll-addresses-dropped {
        type uint32;
        description
          "mi num virtual ll addresses dropped";
      }

      leaf mi-num-virtual-ll-addresses-cached {
        type uint32;
        description
          "mi num virtual ll addresses cached";
      }

      leaf mi-cpuless-init {
        type boolean;
        description "cpuless node list init";
      }

      leaf mi-cpuless-count {
        type uint32;
        description
          "count of cpuless line cards";
      }

      leaf mi-prefer-aib-routes-over-rib-oper {
        type boolean;
        description
          "Prefer AIB routes over RIB/LSD operational state";
      }

      leaf mi-prefer-aib-routes-over-rib-cfg {
        type boolean;
        description
          "Prefer AIB routes over RIB/LSD configured state";
      }

      leaf mi-proactive-arp-nd-enabled {
        type boolean;
        description
          "Proactive-ARP-ND feature";
      }

      leaf mi-xpl-ldi-enabled {
        type boolean;
        description
          "XPL loadinfo is enabled";
      }

      leaf mi-frr-follow-bgp-pic {
        type boolean;
        description
          "fast-reroute follow BGP-PIC configured";
      }

      leaf mi-encap-sharing-disable {
        type boolean;
        description
          "MPLS encapsulation sharing disabled";
      }

      leaf mi-lba-hash-recover {
        type boolean;
        description
          "Consistent-hashing auto-recovery";
      }

      leaf mi-ltrace-multiplier {
        type uint32;
        description
          "The value of trace buffer multiplier";
      }

      leaf mi-retry-syslog-timer {
        type uint32;
        description
          "The value of the retry syslog timer";
      }

      list mi-idb-ext-cleanup-failed-count {
        max-elements 3;
        description
          "Number of recycled idb extensions that failed
         
         cleanup";
        leaf entry {
          type uint32;
          description
            "Number of recycled idb extensions that failed
           
           cleanup";
        }
      }  // list mi-idb-ext-cleanup-failed-count

      list mi-lrpf-stats-fail {
        max-elements 9;
        description
          "Per protocol Failure stats for label RPF";
        leaf entry {
          type uint32;
          description
            "Per protocol Failure stats for label RPF";
        }
      }  // list mi-lrpf-stats-fail

      list mi-lrpf-stats-act {
        max-elements 24;
        description
          "Per protocol actions stats for label RPF";
        leaf entry {
          type uint32;
          description
            "Per protocol actions stats for label RPF";
        }
      }  // list mi-lrpf-stats-act

      list mi-lrpf-num {
        max-elements 3;
        description
          "Per protocol number of label RPFs";
        leaf entry {
          type uint32;
          description
            "Per protocol number of label RPFs";
        }
      }  // list mi-lrpf-num

      list mi-idb-lsec-enabled-num {
        max-elements 3;
        description
          "Number of interfaces having label security
         
         enabled";
        leaf entry {
          type uint32;
          description
            "Number of interfaces having label security
           
           enabled";
        }
      }  // list mi-idb-lsec-enabled-num

      list mi-num-lisp-eid {
        max-elements 3;
        description
          "number of LISP EID prefixes";
        leaf entry {
          type uint32;
          description
            "number of LISP EID prefixes";
        }
      }  // list mi-num-lisp-eid

      list mi-num-lisp-valid-eid {
        max-elements 3;
        description
          "number of LISP EID prefixes eligible for
         
         forwarding";
        leaf entry {
          type uint32;
          description
            "number of LISP EID prefixes eligible for
           
           forwarding";
        }
      }  // list mi-num-lisp-valid-eid

      list mi-cpuless-node {
        max-elements 20;
        description
          "list of cpuless line cards";
        leaf entry {
          type uint32;
          description
            "list of cpuless line cards";
        }
      }  // list mi-cpuless-node

      list mi-retry-backoff-timer {
        max-elements 4;
        description
          "The value of the retry backoff timer";
        leaf entry {
          type uint32;
          description
            "The value of the retry backoff timer";
        }
      }  // list mi-retry-backoff-timer

      list mi-proto-dbg-stat {
        description
          "Per protocol debug stats";
        uses FIB-SH-PROTO-DEBUG-STATS;
      }  // list mi-proto-dbg-stat

      list mi-idb-purge-cntr {
        max-elements 3;
        description
          "the number of counters used for purge counter
         stats";
        uses FIB-SH-PROTO-PURGE-STATS;
      }  // list mi-idb-purge-cntr

      list mi-del {
        description
          "Timestamps of deleted routes";
        uses FIB-SH-ROUTE-DEL-TS;
      }  // list mi-del

      list mi-frr-stat {
        max-elements 3;
        description "FRR statistics";
        uses FIB-SH-PROTO-FRR-STATS;
      }  // list mi-frr-stat

      list mi-retry-syslog-timer-running {
        min-elements 4;
        max-elements 4;
        description
          "is retry syslog/backoff timer running";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list mi-retry-syslog-timer-running
    }  // grouping FIB-SH-MISC

    grouping FIB-SH-TBL-EXT-CLIENT-SUM {
      description
        "FIB external client summary information";
      container ses-pl-sum {
        description "ECD pathlist summary";
        uses FIB-SH-TBL-EXT-PL-SUM;
      }  // container ses-pl-sum

      leaf ses-client-name {
        type string;
        description "External client name";
      }

      leaf ses-feci-fib-proto {
        type uint32;
        description "Registration proto";
      }

      leaf ses-num-regs {
        type uint32;
        description
          "Number of registrations";
      }

      leaf ses-num-pending {
        type uint32;
        description
          "Number of pending notifs";
      }

      leaf ses-client-pulsed-time {
        type uint64;
        description
          "Client pulsed timestamp";
      }

      leaf ses-comp-id {
        type uint32;
        description
          "component-id of the client";
      }

      leaf ses-ecd-version {
        type uint32;
        description "ECD version";
      }
    }  // grouping FIB-SH-TBL-EXT-CLIENT-SUM

    grouping FIB-SH-FRR-NHINFO {
      description
        "FIB per nhinfo information";
      leaf si-frrtype {
        type uint32;
        description "FRR-NHinfo Type";
      }

      leaf si-refcount {
        type uint32;
        description
          "Next Hop Reference Count";
      }

      leaf si-flags {
        type uint32;
        description "FRR nhinfo flags";
      }

      leaf si-tbl-id {
        type uint32;
        description "VRF table ID";
      }

      leaf si-ifh {
        type uint32;
        description "ifh assoc w FRR nh";
      }

      leaf si-main-ifh {
        type uint32;
        description
          "main ifh assoc w prot-frr nh";
      }

      leaf si-linktype {
        type uint32;
        description
          "Linktype using this FRR object";
      }

      leaf si-nh-pfx-proto {
        type uint32;
        description
          "Protocol for next-hop prefix";
      }

      leaf si-nh-pfx {
        type yang:hex-string;
        description "nh prefix";
      }

      leaf si-nh-pfx-len {
        type uint32;
        description "prefix len";
      }

      leaf si-tunid {
        type uint32;
        description "tunnel id for c12k";
      }

      leaf si-frr-ptr {
        type uint64;
        description "frr-nhinfo pointer";
      }

      leaf si-prot-frr-ptr {
        type uint64;
        description
          "prot-frr-nhinfo pointer for a bkup-frr";
      }

      leaf si-parent-nh-ptr {
        type uint64;
        description "parent nhinfo pointer";
      }

      leaf si-partner-nh-ptr {
        type uint64;
        description "partner nhinfo pointer";
      }

      leaf si-repl-parent-type {
        type uint8;
        description
          "replicated parent nhinfo type";
      }

      leaf si-upd-ts {
        type uint64;
        description "update timestamp";
      }
    }  // grouping FIB-SH-FRR-NHINFO

    grouping FIB-SH-NHID-ENTRY {
      description
        "FIB per NHID entry information";
      leaf nh-interface-name-xr {
        type xr:Interface-name;
        description "Next-hop interface";
      }

      leaf nh-address-xr {
        type string;
        description "Next-hop address";
      }

      leaf nh-protocol {
        type uint8;
        description
          "Next-hop address protocol, IPv4/IPv6";
      }

      leaf nh-link-type {
        type uint8;
        description "Payload linktype";
      }

      leaf nh-table-id {
        type uint32;
        description
          "Table-ID entry notified for";
      }

      leaf nh-id-xr {
        type uint32;
        description "NHID value";
      }

      leaf nh-id-application {
        type uint8;
        description "NHID application type";
      }

      leaf version {
        type uint64;
        description "RIB version";
      }

      leaf time-of-last-update-in-msec {
        type uint64;
        description
          "The time of last update in msec";
      }

      leaf encap-id {
        type uint64;
        description "ENCAP ID value";
      }
    }  // grouping FIB-SH-NHID-ENTRY

    grouping MGMT-SRV6-SID-FMT {
      description "SRv6 SID Format Info";
      leaf type {
        type Mgmt-srv6-sid-fmt;
        description "Format type";
      }

      leaf description {
        type string;
        description "Format description";
      }
    }  // grouping MGMT-SRV6-SID-FMT

    grouping MGMT-SRV6-OP-MODE {
      description
        "SRv6 operational mode Info";
      leaf type {
        type Srv6-op-mode;
        description "Mode type";
      }

      leaf description {
        type string;
        description "Mode description";
      }
    }  // grouping MGMT-SRV6-OP-MODE

    grouping FIB-SRV6-GBL-MODE-INFO {
      description
        "FIB SRv6 global mode info";
      container mode {
        description "Mode (type and desc)";
        uses MGMT-SRV6-OP-MODE;
      }  // container mode

      container sid-format {
        description "SID Format";
        uses MGMT-SRV6-SID-FMT;
      }  // container sid-format

      leaf block-srv6-space {
        type string;
        description "Block SRv6 space";
      }
    }  // grouping FIB-SRV6-GBL-MODE-INFO

    grouping FIB-SRV6-GBL-UPD-SET-OR-PROP {
      description
        "FIB SRv6 global param set or propagate value";
      leaf use-default {
        type boolean;
        description "Use default value";
      }

      leaf do-propagate {
        type boolean;
        description
          "Propagate from incoming packet/frame";
      }

      leaf value {
        type uint8;
        description "Specific value";
      }
    }  // grouping FIB-SRV6-GBL-UPD-SET-OR-PROP

    grouping FIB-SRV6-GBL-UPD {
      description "FIB SRv6 global update";
      container encap-hop-limit {
        description "Encap Hop-limit info";
        uses FIB-SRV6-GBL-UPD-SET-OR-PROP;
      }  // container encap-hop-limit

      container encap-traffic-class {
        description
          "Encap Traffic-class info";
        uses FIB-SRV6-GBL-UPD-SET-OR-PROP;
      }  // container encap-traffic-class

      leaf srv6-enabled {
        type boolean;
        description "Is SRv6 enabled?";
      }

      leaf encap-source-address {
        type inet:ipv6-address;
        description "Encap Source Address";
      }

      list mode-info {
        description "Info per SRv6 Mode";
        uses FIB-SRV6-GBL-MODE-INFO;
      }  // list mode-info
    }  // grouping FIB-SRV6-GBL-UPD

    grouping FIB-ATTRIBUTE-SUMMARY {
      description
        "Summary of downloaded fib route attributes";
    }  // grouping FIB-ATTRIBUTE-SUMMARY

    grouping FIB-SH-REC-NH-INT {
      description
        "FIB RNH's Internal information";
      leaf string-rep {
        type string;
        description
          "String Representation of a RNH";
      }
    }  // grouping FIB-SH-REC-NH-INT

    grouping FIB-SH-REC-NH-DEP-INT {
      description
        "RNH Dependent's Internal Info";
      container fib-rtep-hist {
        description "FIB Rtep History";
        uses EVT-HIST-INFO;
      }  // container fib-rtep-hist

      container fib-ecd-hist {
        description "FIB Ecd History";
        uses EVT-HIST-INFO;
      }  // container fib-ecd-hist
    }  // grouping FIB-SH-REC-NH-DEP-INT

    grouping FIB-SH-NHINFO-EXT-TEP-DET {
      description
        "NHINFO entry extension object information";
      leaf nh-info-tep-type {
        type uint8;
        description "TEP type";
      }

      leaf is-tep-single-pass {
        type boolean;
        description "Is TEP is Single Pass";
      }
    }  // grouping FIB-SH-NHINFO-EXT-TEP-DET

    grouping FIB-SH-NHINFO-EXT-REP-DET {
      description
        "NHINFO entry extension object information";
      leaf nh-info-replicated-type {
        type uint8;
        description "Replicated NHINFO type";
      }

      leaf nh-info-replicated-nh-id {
        type uint32;
        description
          "NHID of the replicated NHINFO";
      }

      leaf nh-info-replicated-encap-id {
        type uint64;
        description
          "ENCAP ID of the replicated NHINFO";
      }

      leaf nh-info-replicated-interface {
        type xr:Interface-name;
        description
          "Interface of the replicated NHINFO";
      }
    }  // grouping FIB-SH-NHINFO-EXT-REP-DET

    grouping FIB-SH-NHINFO-EXT-CMN-DET {
      description
        "FIB SH NHINFO EXT CMN DET";
      container snecd-nhr {
        when
          "../type = 'replicated-nh-info'" {
          description
            "../type = 'ReplicatedNHINFO'";
        }
        description "snecd nhr";
        uses FIB-SH-NHINFO-EXT-REP-DET;
      }  // container snecd-nhr

      container snecd-tep {
        when "../type = 'tunnel-endpoint'" {
          description
            "../type = 'TunnelEndpoint'";
        }
        description "snecd tep";
        uses FIB-SH-NHINFO-EXT-TEP-DET;
      }  // container snecd-tep

      leaf type {
        type Fib-nhinfo-ext-bag;
        description "type";
      }
    }  // grouping FIB-SH-NHINFO-EXT-CMN-DET

    grouping FIB-SH-EXT-BASE {
      description
        "FIB object extension base information";
      container object-base {
        description
          "FIB Object Base information";
        uses FIB-SH-FIB-OBJ-BASE;
      }  // container object-base

      leaf parent-object-pointer {
        type uint64;
        description
          "FIB Extension Object's parent pointer";
      }

      leaf back-object-pointer {
        type uint64;
        description
          "FIB Extension Object's back pointer";
      }
    }  // grouping FIB-SH-EXT-BASE

    grouping FIB-SH-NHINFO-EXT-DET {
      description
        "NHINFO entry extension internal information";
      container nh-info-extension-base {
        description
          "NHINFO Extension object base information";
        uses FIB-SH-EXT-BASE;
      }  // container nh-info-extension-base

      container nh-info-extension-detail {
        description
          "NHINFO Extension Detail Information";
        uses FIB-SH-NHINFO-EXT-CMN-DET;
      }  // container nh-info-extension-detail
    }  // grouping FIB-SH-NHINFO-EXT-DET

    grouping FIB-SH-NHINFO-EXT {
      description "FIB per nhinfo info";
      list nh-info-extension-detail {
        description
          "NHINFO Extension Detail";
        uses FIB-SH-NHINFO-EXT-DET;
      }  // list nh-info-extension-detail
    }  // grouping FIB-SH-NHINFO-EXT

    grouping FIB-SH-NHINFO-PWHE-EXT {
      description "FIB PW-HE specific info";
      leaf pwhe-adjacency-client-data {
        type uint32;
        description
          "PW-HE specific client data in adjacency";
      }

      leaf vctype {
        type uint32;
        description "VC type";
      }

      leaf vc-internal-label {
        type uint32;
        description "VC Internal Label";
      }

      leaf cw-enabled {
        type boolean;
        description "Is CW enabled?";
      }

      leaf l2-overhead-bytes {
        type uint16;
        units "byte";
        description
          "L2 overhead bytes for interface stats accounting";
      }

      leaf dot1q-vlan-tag {
        type uint32;
        description "VLAN tag";
      }
    }  // grouping FIB-SH-NHINFO-PWHE-EXT

    grouping FIB-SH-NHINFO {
      description
        "FIB per nhinfo information";
      container si-pwhe {
        description
          "PW-HE interface extension";
        uses FIB-SH-NHINFO-PWHE-EXT;
      }  // container si-pwhe

      container nh-info-extension {
        description "NHinfo Extensions";
        uses FIB-SH-NHINFO-EXT;
      }  // container nh-info-extension

      leaf si-link-proto {
        type uint32;
        description
          "FIB Protocol Type for NHINFO linktype";
      }

      leaf si-nhtype {
        type uint32;
        description "NHinfo Type";
      }

      leaf si-ifh {
        type uint32;
        description "Ifhndl assoc w nhinfo";
      }

      leaf si-pfi-interface-type {
        type uint32;
        description "Pamna Interface Type";
      }

      leaf si-adj-ptr {
        type uint32;
        description "Adj Ptr";
      }

      leaf si-adj-present {
        type boolean;
        description "nhinfo point to adj";
      }

      leaf si-special-type {
        type uint32;
        description
          "nature of special nhinfo";
      }

      leaf si-refcount {
        type uint32;
        description
          "Next Hop Reference Count";
      }

      leaf si-flags {
        type uint32;
        description "nhinfo flags";
      }

      leaf nh-info-base-extended-flags {
        type uint16;
        description
          "NHInfo Base Extended Flags";
      }

      leaf si-adj-if {
        type uint32;
        description "ADJ Interface";
      }

      leaf si-ext-pfx {
        type yang:hex-string;
        description "Extension Prefix";
      }

      leaf si-ext-pfx-len {
        type uint32;
        description "Extension Prefix Len";
      }

      leaf si-ext-pfx-proto {
        type uint32;
        description
          "Extension Prefix Protocol";
      }

      leaf si-adj-address {
        type yang:hex-string;
        description "AIB L3 Address";
      }

      leaf si-adj-addrlen {
        type uint32;
        description "ADJ L3 address length";
      }

      leaf si-adj-addr-proto {
        type uint32;
        description
          "ADJ L3 address Protocol";
      }

      leaf si-adj-rw-len {
        type uint32;
        description "Length of Macstring";
      }

      leaf si-adj-rw {
        type yang:hex-string;
        description
          "Macstring for Adjacency";
      }

      leaf adjacency-route-preference {
        type Fib-bag-adj-pref;
        description
          "Adjacency route preference";
      }

      leaf si-dep-nhinfo-type {
        type uint32;
        description "Depenedent nhinfo type";
      }

      leaf si-dep-nhinfo {
        type uint32;
        description "Dependent nhinfo";
      }

      leaf si-dep-nhinfo-ifh {
        type uint32;
        description
          "Dependent nhinfo ifhndl";
      }

      leaf si-bkup-frr {
        type uint32;
        description
          "pointer to Backup FRR obj";
      }

      leaf si-protect-frr {
        type uint32;
        description
          "pointer to protect FRR object";
      }

      leaf si-bkup-nhinfo {
        type uint32;
        description "Bacckup NHINFO obj";
      }

      leaf si-bkup-ifh {
        type uint32;
        description "Bacckup IFH";
      }

      leaf si-bkup-addr {
        type yang:hex-string;
        description "Bkup L3 Address";
      }

      leaf si-bkup-addrlen {
        type uint32;
        description "BKup L3 address length";
      }

      leaf si-bkup-addr-proto {
        type uint32;
        description
          "BKup L3 address Protocol";
      }

      leaf si-frr-active {
        type boolean;
        description
          "is FRR currently active";
      }

      leaf si-attr-is-ext-mgd {
        type boolean;
        description
          "NH is externally managed";
      }

      leaf si-attr-is-incomp {
        type boolean;
        description "NH is incomplete";
      }

      leaf si-attr-is-tunnel {
        type boolean;
        description
          "NH is assoc w a TE tunnel";
      }

      leaf si-attr-is-tunnel-srte {
        type boolean;
        description
          "NH is assoc w a SRTE tunnel";
      }

      leaf si-attr-is-gre-tunnel {
        type boolean;
        description
          "NH is assoc w a GRE tunnel";
      }

      leaf si-gre-ti {
        type uint64;
        description "GRE tunnel info";
      }

      leaf si-gre-ti-flags {
        type uint32;
        description
          "Flags on GRE tunnel info";
      }

      leaf si-gre-ti-refcnt {
        type uint32;
        description
          "Refcount on GRE tunnel info";
      }

      leaf si-gre-tos-propagate {
        type boolean;
        description
          "Is GRE TOS propagate set";
      }

      leaf si-hardware {
        type yang:hex-string;
        description "Platform Hardware info";
      }

      leaf si-nhinfo-ptr {
        type uint32;
        description "nhinfo pointer";
      }

      leaf si-fnb-idb-ptr {
        type uint32;
        description "pointer to idb";
      }

      leaf si-anc-ifh {
        type uint32;
        description "Ancestor IFH";
      }

      leaf si-gre-ti-resolving-leafp {
        type uint64;
        description "GRE resolving ip-leaf";
      }

      leaf si-gre-dest-addr {
        type yang:hex-string;
        description "GRE dest address";
      }

      leaf si-nhid {
        type uint32;
        description
          "NHID value in the TX NH";
      }

      leaf si-upd-ts {
        type uint64;
        description "NH update timestamp";
      }

      leaf nh-is-in-oor-state {
        type boolean;
        description "is NH in OOR";
      }
    }  // grouping FIB-SH-NHINFO

    grouping FIB-SH-REC-NH-DEP {
      description
        "FIB recursive nexthop dependant information";
      list fib-sh-rec-nh-dep {
        description "Next dependant";
        container rnd-shadow-nh {
          description "VXLAN shadow NH";
          uses FIB-SH-NHINFO;
        }  // container rnd-shadow-nh

        container rnd-int {
          description
            "RNH dependent's Internal Info";
          uses FIB-SH-REC-NH-DEP-INT;
        }  // container rnd-int

        leaf rnd-type {
          type uint32;
          description "Dependant type";
        }

        leaf rnd-tunnel-id {
          type uint32;
          description "Tunnel endpoint id";
        }

        leaf rnd-ifh {
          type xr:Interface-name;
          description "Interface handle";
        }

        leaf rnd-ref-count {
          type uint32;
          description "Ref count";
        }

        leaf rnd-resolved {
          type boolean;
          description "Dependant resolved";
        }

        leaf rnd-flags {
          type uint32;
          description "Dependant flags";
        }

        leaf rnd-loc-tun-up {
          type uint32;
          description "Local tunnel status";
        }

        leaf rnd-data {
          type yang:hex-string;
          description
            "TEP encapsulation details";
        }

        leaf rnd-src-size {
          type uint32;
          description
            "Source addr pool size";
        }

        leaf rnd-stale {
          type boolean;
          description "Stale flag";
        }

        leaf rnd-retry {
          type boolean;
          description "Retry flag";
        }

        leaf rnd-gti-ptr {
          type uint64;
          description "GRE tunnel info ptr";
        }

        leaf rnd-nh-ptr {
          type uint64;
          description
            "GRE/VXLAN NH-info ptr";
        }

        leaf rnd-parent-nh-ptr {
          type uint64;
          description
            "VXLAN parent NH-info ptr";
        }

        leaf rnd-nh-proto {
          type Fib-bag-protocol;
          description "NH proto";
        }

        leaf rnd-vxlan-rtep-ptr {
          type uint32;
          description "VXLAN rTEP info ptr";
        }

        leaf rnd-vxlan-evni {
          type uint32;
          description "VXLAN egress VNI";
        }

        leaf rnd-vxlan-ol-tblid {
          type uint32;
          description "VXLAN overlay tbl id";
        }

        leaf rnd-hw-info {
          type yang:hex-string;
          description "Opaque hardware info";
        }
      }  // list fib-sh-rec-nh-dep
    }  // grouping FIB-SH-REC-NH-DEP

    grouping FIB-SH-REC-NH {
      description
        "FIB recursive nexthop information";
      container rn-first-dep {
        description "First dependant";
        uses FIB-SH-REC-NH-DEP;
      }  // container rn-first-dep

      container rn-int {
        description
          "Internal representation of an RNH";
        uses FIB-SH-REC-NH-INT;
      }  // container rn-int

      leaf rn-prefix {
        type yang:hex-string;
        description
          "Recursive nexthop prefix";
      }

      leaf rn-prefix-len {
        type uint32;
        description "Prefix length";
      }

      leaf rn-resolved {
        type boolean;
        description
          "Recursive nexthop resolved";
      }

      leaf rn-resolve-prefix {
        type yang:hex-string;
        description "Resolving prefix";
      }

      leaf rn-resolve-prefix-len {
        type uint32;
        description
          "Resolving prefix length";
      }

      leaf rn-v4mappedv6 {
        type boolean;
        description
          "Address is v4-mapped-v6";
      }

      leaf rn-hw-info-incl {
        type boolean;
        description "Hardware info included";
      }
    }  // grouping FIB-SH-REC-NH

    grouping EVT-HIST-ENTRY {
      description "Event history Entry";
      leaf evt-timestamp {
        type string;
        description
          "The timestamp of the event";
      }

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

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

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

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

      list evt-data {
        description "Optional data";
        leaf entry {
          type uint32;
          description "Optional data";
        }
      }  // list evt-data
    }  // grouping EVT-HIST-ENTRY

    grouping EVT-HIST-INFO {
      description "Per object event history";
      leaf evt-class-name {
        type string;
        description "Class name string";
      }

      list evt-entry {
        description "Array of event entries";
        uses EVT-HIST-ENTRY;
      }  // list evt-entry
    }  // grouping EVT-HIST-INFO

    grouping FIB-SH-INT-INTERNAL {
      description
        "FIB per interface internal information";
      container fib-idb-hist {
        description "Event History for IDB";
        uses EVT-HIST-INFO;
      }  // container fib-idb-hist

      container fib-srte-head-hist {
        description
          "Event History for Srtehead";
        uses EVT-HIST-INFO;
      }  // container fib-srte-head-hist
    }  // grouping FIB-SH-INT-INTERNAL

    grouping FIB-SH-INT-DET {
      description
        "FIB per interface detail information";
      leaf interface-mtu {
        type uint16;
        description "Interface Protocol MTU";
      }

      leaf forwarding-flag {
        type boolean;
        description
          "Forwarding enabled/disabled flag";
      }

      leaf rpf-configured-flag {
        type boolean;
        description "RPF configured flag";
      }

      leaf rpf-mode {
        type Fib-rpf-mode;
        description "RPF mode";
      }

      leaf default-route-with-rpf {
        type boolean;
        description
          "Allow default route with RPF";
      }

      leaf self-ping-with-rpf {
        type boolean;
        description
          "Allow selfping with RPF";
      }

      leaf bgp-pa-input-configured-flag {
        type boolean;
        description "BGP PA configured flag";
      }

      leaf source-bgp-pa-input-configured-flag {
        type boolean;
        description
          "src BGP PA configured flag";
      }

      leaf destination-bgp-pa-input-configured-flag {
        type boolean;
        description
          "dst BGP PA configured flag";
      }

      leaf bgp-pa-output-configured-flag {
        type boolean;
        description "BGP PA configured flag";
      }

      leaf source-bgp-pa-output-configured-flag {
        type boolean;
        description
          "src BGP PA configured flag";
      }

      leaf destination-bgp-pa-output-configured-flag {
        type boolean;
        description
          "dst BGP PA configured flag";
      }

      leaf icmp-flag {
        type uint32;
        description "ICMP  configured flag";
      }

      leaf multi-label-drop-flag {
        type boolean;
        description
          "Drop packets with multiple-label-stack if set";
      }
    }  // grouping FIB-SH-INT-DET

    grouping FIB-SH-INT {
      description
        "FIB per interface information";
      container detail-fib-int-information {
        description
          "Detailed FIB interface information";
        uses FIB-SH-INT-DET;
      }  // container detail-fib-int-information

      container si-internal {
        description "Internal Information";
        uses FIB-SH-INT-INTERNAL;
      }  // container si-internal

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

      leaf fib-interface-type {
        type uint32;
        description "FIB Interface type";
      }

      leaf fib-id-pointer {
        type uint32;
        description "Pointer to fibidb";
      }

      leaf fib-id-flags {
        type uint32;
        description "Flags on fibidb";
      }

      leaf fib-id-extension-pointer {
        type uint32;
        description
          "Pointer to fibidb extension";
      }

      leaf fib-id-extension-flags {
        type uint32;
        description
          "Flags on fibidb extension";
      }

      leaf number-of-dependent-next-hop-information {
        type uint32;
        description
          "Number of dependent nhinfo's";
      }

      leaf vrf-local-cef-information-pointer {
        type uint32;
        description "Vrf local cef info ptr";
      }

      leaf reference-count {
        type uint16;
        description "Reference count";
      }

      leaf last-modified-time {
        type uint32;
        description "Time last modified";
      }

      leaf last-operation {
        type Fibidb-oper;
        description "Last Oper";
      }

      leaf protocol-enabled {
        type boolean;
        description
          "Is the protocol configured?";
      }

      leaf referance-count-for-protocol {
        type uint32;
        description
          "Reference count for the protocol";
      }

      leaf number-of-input-packets {
        type uint64;
        description
          "Number of input packets";
      }

      leaf number-of-input-bytes {
        type uint64;
        units "byte";
        description "Number of input bytes";
      }

      leaf number-of-output-packets {
        type uint64;
        description
          "Number of output packets";
      }

      leaf number-of-output-bytes {
        type uint64;
        units "byte";
        description "Number of output bytes";
      }

      leaf interface-up-flag {
        type boolean;
        description "Interface up flag";
      }

      leaf per-packet-load-balancing-flag {
        type boolean;
        description
          "Per packet loadbalancing flag";
      }

      leaf p2p-interface-flag {
        type boolean;
        description "P2P interface flag";
      }

      leaf loopback-interface-flag {
        type boolean;
        description
          "Loopback interface flag";
      }

      leaf null-interface-flag {
        type boolean;
        description "Null interface flag";
      }

      leaf tunnel-interface-flag {
        type boolean;
        description "Tunnel interface flag";
      }

      leaf gre-tunnel-interface-flag {
        type boolean;
        description
          "GRE Tunnel interface flag";
      }

      leaf punt-packets-from-fib-switching-flag {
        type boolean;
        description
          "Punt packets from FIB switching flag";
      }

      leaf drop-packets-while-fib-switching-flag {
        type boolean;
        description
          "Drop packets while FIB switching flag";
      }

      leaf punt-packets-from-linecard-flag {
        type boolean;
        description
          "Punt packets from linecard flag";
      }

      leaf primary-ipv4-address {
        type string {
          length "0..52";
        }
        description
          "Pimary local v4 address for the interface";
      }

      leaf primary-ipv6-address {
        type string {
          length "0..52";
        }
        description
          "Pimary local v6 address for the interface";
      }
    }  // grouping FIB-SH-INT

    grouping FIB-SH-TBL-FIB-DVAR-VRF-DET {
      description
        "FIB table destination VRF information";
      container vrf-leak-timestamp {
        description
          "Destination Vrf Leak Timestamp";
        uses FIB-SH-TIMESPEC;
      }  // container vrf-leak-timestamp

      leaf destinationvrf-name {
        type string;
        description "Destination Vrf Name";
      }

      leaf destinationvrf-table-id {
        type uint32;
        description
          "Destination Vrf Table ID";
      }

      leaf destinationvrf-table-pointer {
        type uint64;
        description
          "Destination Vrf Table Ptr";
      }
    }  // grouping FIB-SH-TBL-FIB-DVAR-VRF-DET

    grouping FIB-SH-TBL-FIB-DVARS {
      description
        "FIB table destination information";
      leaf protocol {
        type Fib-bag-protocol;
        description "Src Vrf Protocol";
      }

      leaf prefix-length-xr {
        type uint32;
        description "Src Prefix Length";
      }

      leaf source-vrf {
        type uint32;
        description "Src VRF";
      }

      leaf destination-count {
        type uint32;
        description
          "Count of Number of Destination Vrfs this prefix
         is leaked in";
      }

      leaf flags {
        type uint32;
        description "Flags";
      }

      list destinationvrf-detail {
        description "Destination Vrf Detail";
        uses FIB-SH-TBL-FIB-DVAR-VRF-DET;
      }  // list destinationvrf-detail
    }  // grouping FIB-SH-TBL-FIB-DVARS

    grouping FIB-ATTRIBUTE-DET {
      description
        "Detailed info for downloaded fib route attributes";
      leaf sfa-attribute-id {
        type uint32;
        description "BGP attribute id";
      }

      leaf sfa-lcl-attribute-id {
        type uint32;
        description "BGP local attribute id";
      }

      leaf sfa-local-pref {
        type uint32;
        description
          "BGP attribute local preference of the path";
      }

      leaf sfa-origin-as {
        type uint32;
        description
          "BGP attribute origin as";
      }

      leaf sfa-next-hop-as {
        type uint32;
        description
          "BGP attribute next hop as";
      }

      leaf sfa-aspath-string {
        type yang:hex-string;
        description "As path string";
      }

      leaf sfa-extended-community-string {
        type yang:hex-string;
        description "extcom st";
      }

      leaf sfa-community-string {
        type yang:hex-string;
        description "com st";
      }

      leaf sfa-extended-community {
        type uint32;
        description "extended community";
      }
    }  // grouping FIB-ATTRIBUTE-DET

    grouping FIB-SH-TBL-FIB-EXT-DET {
      description
        "FIB entry extension list information";
      leaf context-label-flag {
        type boolean;
        description "Context Label Exist";
      }

      leaf context-label {
        type uint32;
        description "Context Label";
      }
    }  // grouping FIB-SH-TBL-FIB-EXT-DET

    grouping FIB-SH-TBL-FIB-EXT-CMN-DET {
      description
        "FIB SH TBL FIB EXT CMN DET";
      container sfecd-le {
        when "../type = 'leaf-extension'" {
          description
            "../type = 'LeafExtension'";
        }
        description "sfecd le";
        uses FIB-SH-TBL-FIB-EXT-DET;
      }  // container sfecd-le

      leaf type {
        type Fib-sh-tbl-fib-ext-bag;
        description "type";
      }
    }  // grouping FIB-SH-TBL-FIB-EXT-CMN-DET

    grouping MGMT-SRV6-ENDPOINT-BEHAVIOR {
      description
        "SRv6 Endpoint Behavior Info";
      leaf type {
        type Mgmt-srv6-endpoint;
        description "Behavior type";
      }

      leaf description {
        type string;
        description "Behavior description";
      }
    }  // grouping MGMT-SRV6-ENDPOINT-BEHAVIOR

    grouping FIB-SH-TBL-SRV6-RECYCLE {
      description
        "SRv6 packet recycle information for large SID
       stacks";
      list fib-sh-tbl-srv6-recycle {
        description
          "SRv6 packet recycling information";
        leaf internal-id {
          type string {
            length "0..52";
          }
          description
            "The internal ID containing more SID for packet
           reycling";
        }

        leaf srv6-sid-list-subset {
          type string;
          description
            "The subset of the SRv6 SID list of the current
           prefix";
        }
      }  // list fib-sh-tbl-srv6-recycle
    }  // grouping FIB-SH-TBL-SRV6-RECYCLE

    grouping FIB-SH-TBL-PATH-SRV6-INFO {
      description
        "SRv6 path information for FIB table entries";
      container srv6-packet-recycling-information {
        description
          "SRv6 Packet recycling information";
        uses FIB-SH-TBL-SRV6-RECYCLE;
      }  // container srv6-packet-recycling-information

      leaf srv6-encapsulation-behavior {
        type string;
        description
          "SRv6 Per-path Encapsulation Behavior";
      }

      leaf srv6-sid-list {
        type string;
        description "SRv6 SID list";
      }

      leaf srv6-evpn-ac-interface {
        type xr:Interface-name;
        description
          "SRv6 EVPN attached circuit interface";
      }

      leaf srv6-evpn-xconnect-id {
        type uint32;
        description "SRv6 EVPN xconnect ID";
      }
    }  // grouping FIB-SH-TBL-PATH-SRV6-INFO

    grouping FIB-SH-TBL-MPLS-LABEL-STACK {
      description
        "mpls label stack information for FIB table
       entries";
      leaf number-of-labels {
        type uint32;
        description "Total number of labels";
      }

      leaf out-interface {
        type xr:Interface-name;
        description "Outgoing Interface";
      }

      leaf nh-address {
        type string {
          length "0..52";
        }
        description "Next Hop address";
      }

      list lstack {
        max-elements 23;
        description "Label Stack";
        leaf entry {
          type uint32;
          description "Label Stack";
        }
      }  // list lstack
    }  // grouping FIB-SH-TBL-MPLS-LABEL-STACK

    grouping FIB-SH-TBL-PATH-MPLS-INFO {
      description
        "mpls path information for FIB table entries";
      leaf local-lable {
        type uint32;
        description "LocalLable";
      }

      leaf recursive-fwd-chain {
        type boolean;
        description "RecursiveFwdChain";
      }

      leaf number-of-igp-paths {
        type uint32;
        description "NumberOfIGPPaths";
      }

      leaf remote-backup {
        type boolean;
        description "RemoteBackupPath";
      }

      list recursive-lbl-stack {
        description "Recursive Label(s)";
        leaf entry {
          type uint32;
          description "Recursive Label(s)";
        }
      }  // list recursive-lbl-stack

      list igp-label-stack-array {
        description "igp label stack array";
        uses FIB-SH-TBL-MPLS-LABEL-STACK;
      }  // list igp-label-stack-array
    }  // grouping FIB-SH-TBL-PATH-MPLS-INFO

    grouping FIB-SH-TBL-NNH-PATH {
      description
        "Detailed Next Next Hop Information";
      leaf next-next-hop-index {
        type uint8;
        description "Next next hop index";
      }

      leaf next-next-hop-prefix {
        type string {
          length "0..52";
        }
        description "Next next hop prefix";
      }

      leaf next-next-hop-interface {
        type uint32;
        description
          "Next next hop interface index";
      }
    }  // grouping FIB-SH-TBL-NNH-PATH

    grouping FIB-SH-IPENCAP-HDR-DET {
      description
        "Detailed IP Encap Header Description";
      leaf ip-encap-hdr-type {
        type Fib-sh-ipencap-hdr;
        description "Header Type";
      }

      leaf ip-encap-hdrp {
        type yang:hex-string;
        description "Static Header";
      }

      leaf ip-encap-hdr-dyn {
        type uint32;
        description "Dynamic Header Fields";
      }
    }  // grouping FIB-SH-IPENCAP-HDR-DET

    grouping FIB-SH-IPENCAP-DET {
      description
        "Detailed IP Encap Description";
      leaf ip-encap-hdr-count {
        type uint8;
        description "Header Count";
      }

      leaf ip-encap-locks {
        type uint32;
        description "IPEncap Object Locks";
      }

      leaf ip-encap-transport-tbl {
        type uint32;
        description "Transport Table";
      }

      leaf ipe-transport-vrf-name {
        type string;
        description "Transport VRF name";
      }

      leaf ip-encap-transport-af {
        type uint32;
        description "Transport AF";
      }

      leaf ip-encap-payload-af {
        type uint32;
        description "Payload AF";
      }

      leaf ip-encap-payload-mtu {
        type uint16;
        description "Payload MTU";
      }

      leaf ip-encap-parent {
        type uint32;
        description "Pointer to parent";
      }

      leaf ip-encap-parent-type {
        type uint32;
        description
          "Parent type enumeration";
      }

      list ip-encap-hdr {
        description "Headers";
        uses FIB-SH-IPENCAP-HDR-DET;
      }  // list ip-encap-hdr
    }  // grouping FIB-SH-IPENCAP-DET

    grouping FIB-SH-TBL-PATH-DET {
      description
        "Detailed path information for FIB table entries";
      leaf ip-address-to-recurse {
        type string {
          length "0..52";
        }
        description
          "IP address to recurse to";
      }

      leaf label-to-recurse {
        type uint32;
        description
          "Local label to recurse over";
      }

      leaf srv6-sid-to-recurse {
        type inet:ipv6-address;
        description
          "SRv6 SID to recurse over";
      }

      leaf detail-next-hop-prefix {
        type string {
          length "0..52";
        }
        description "Next hop prefix";
      }

      leaf next-hop-mask-length {
        type uint8;
        description "Next hop mask length";
      }

      leaf interface-associated-path {
        type xr:Interface-name;
        description
          "Interface associated with this path";
      }

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

      leaf next-hop-vrf {
        type string;
        description "Next hop VRF";
      }

      leaf tunnle-endpoint-id {
        type uint32;
        description "Tunnel endpoint id";
      }

      leaf lisprlocid {
        type uint32;
        description "LISP RLOC ID";
      }

      leaf number-of-dependencies-this-path {
        type uint32;
        description
          "No. of dependents for this path";
      }

      leaf robin-reset-value {
        type uint8;
        description
          "Round robin reset value";
      }

      leaf recurse-prefix-object {
        type boolean;
        description
          "Is recursion object a leaf?";
      }

      leaf next-prefix-recursion {
        type string;
        description
          "Next prefix recursion in the path";
      }

      leaf next-prefix-length {
        type uint8;
        description "Next prefix length";
      }

      leaf recurse-prefix-object2 {
        type boolean;
        description
          "Recursion has two leaves (e.g. implicit-null
         path)";
      }

      leaf next-prefix-recursion2 {
        type string;
        description
          "Next prefix2 recursion in the path";
      }

      leaf next-prefix-length2 {
        type uint8;
        description "Next prefix2 length";
      }

      leaf detail-fib-adjacency-type {
        type Fib-adjacency-show;
        description
          "FIB entry adjacency type";
      }

      leaf current-path-flag {
        type boolean;
        description "Current path flag";
      }

      leaf recursive-path-information {
        type boolean;
        description
          "Recursive path information is available";
      }

      leaf external-adjacency {
        type boolean;
        description
          "Path is an external adjacency";
      }

      leaf fib-path-nh-information-type {
        type Fib-neh;
        description "FIB Nhinfo type";
      }

      leaf fib-path-nh-information-type-special {
        type Fib-neh-special;
        description
          "FIB Nhinfo type special";
      }

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

      leaf tunnel-class {
        type uint8;
        description
          "Tunnel class of the path";
      }

      leaf tunnel-is-forward-class {
        type boolean;
        description
          "Flag to indicate if the Tunnel is forward class";
      }

      list spd-ipencap {
        description "IP Encap";
        uses FIB-SH-IPENCAP-DET;
      }  // list spd-ipencap

      list next-next-hop {
        description "Next Next hop sets";
        uses FIB-SH-TBL-NNH-PATH;
      }  // list next-next-hop
    }  // grouping FIB-SH-TBL-PATH-DET

    grouping FIB-SH-TBL-PATH {
      description
        "Brief path information for FIB table entries";
      list fib-sh-tbl-path {
        description "Next entry in the path";
        container more-detail-about-path {
          description
            "More detail about this path entry";
          uses FIB-SH-TBL-PATH-DET;
        }  // container more-detail-about-path

        container mpls-information-for-path {
          description
            "mpls info for this path entry";
          uses FIB-SH-TBL-PATH-MPLS-INFO;
        }  // container mpls-information-for-path

        container srv6-information-for-path {
          description
            "SRv6 info for this path entry";
          uses FIB-SH-TBL-PATH-SRV6-INFO;
        }  // container srv6-information-for-path

        leaf hardware-information {
          type yang:hex-string;
          description "Hardware info";
        }

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

        leaf brief-next-hop-prefix {
          type string {
            length "0..52";
          }
          description "Next hop prefix";
        }

        leaf via-label-to-recurse {
          type uint32;
          description
            "Local label to recurse over";
        }

        leaf via-srv6-sid-to-recurse {
          type inet:ipv6-address;
          description
            "SRv6 SID to recurse over";
        }

        leaf brief-pnode-address {
          type string {
            length "0..52";
          }
          description "P-node address";
        }

        leaf brief-qnode-address {
          type string {
            length "0..52";
          }
          description "Q-node address";
        }

        leaf brief-lfa-protection-type {
          type Fib-update-path-lfa-protection;
          description "LFA protection type";
        }

        leaf resolved-path {
          type boolean;
          description "Resolved path";
        }

        leaf recursive-path {
          type boolean;
          description "Recursive path";
        }

        leaf packets-received-path {
          type boolean;
          description
            "Packets received on this path";
        }

        leaf attached-path {
          type boolean;
          description "Attached path";
        }

        leaf backup-path {
          type boolean;
          description "Backup path";
        }

        leaf best-external-path {
          type boolean;
          description "Best external path";
        }

        leaf protect-ignore {
          type boolean;
          description
            "Is protection ignored";
        }

        leaf path-dlb {
          type boolean;
          description
            "Is this the path used for DLB";
        }

        leaf path-flags {
          type uint32;
          description "Path flags";
        }

        leaf path-info-flags {
          type uint16;
          description "Path Info flags";
        }

        leaf path-index {
          type uint8;
          description "Path index";
        }

        leaf backup-index {
          type uint8;
          description "Backup path index";
        }

        leaf next-hop-index {
          type uint32;
          description "Next Hop Index";
        }

        leaf parent-interface-handle {
          type xr:Interface-name;
          description
            "Parent Interface Handle";
        }

        leaf recursionvia-len {
          type uint8;
          description
            "recursion via /N constraint";
        }
      }  // list fib-sh-tbl-path
    }  // grouping FIB-SH-TBL-PATH

    grouping FIB-ADDR-STR {
      description "FIB address";
      leaf address {
        type string {
          length "0..60";
        }
        description "address";
      }
    }  // grouping FIB-ADDR-STR

    grouping FIB-SH-TBL-LOADINFO-INT {
      description
        "Internal load sharing information arrays for FIB
       table entries";
      leaf level-ofldis {
        type uint8;
        description "level of ldis";
      }

      leaf number-of-ldis {
        type uint8;
        description "no. of ldis";
      }

      leaf maximum-index-arrays {
        type uint32;
        description
          "Maximum index of the load sharing information
         arrays";
      }

      leaf maximum-slots {
        type uint32;
        description "Maximum slots";
      }

      leaf normalized-weights {
        type yang:hex-string;
        description "Normalized weights";
      }

      leaf tunnel-class-value {
        type yang:hex-string;
        description "Tunnel class value";
      }

      leaf is-pbts-info-valid {
        type boolean;
        description "PBTS info valid flag";
      }

      leaf pbts-class-offset {
        type yang:hex-string;
        description "PBTS class offset";
      }

      leaf pbts-class-num-paths {
        type yang:hex-string;
        description "PBTS class num paths";
      }

      leaf pbts-fallback-mapped-class {
        type yang:hex-string;
        description
          "PBTS class falls back to class";
      }

      leaf round-robin-disable {
        type boolean;
        description
          "Flag to indicate if the Round Robin is Disabled
         or not";
      }

      leaf ldi-next-hop-buckets {
        type uint8;
        description
          "Number of LDI next hop buckets";
      }

      leaf platform-hardware-information {
        type yang:hex-string;
        description "Platform Hardware info";
      }

      list path-indice {
        description "Path indices";
        leaf entry {
          type uint8;
          description "Path indices";
        }
      }  // list path-indice

      list path-ldi-number {
        description "Path indices";
        leaf entry {
          type uint8;
          description "Path indices";
        }
      }  // list path-ldi-number

      list sanity-flag {
        description "Sanity flag";
        leaf entry {
          type boolean;
          description "Sanity flag";
        }
      }  // list sanity-flag

      list interface-handle {
        description "Interface handle";
        leaf entry {
          type xr:Interface-name;
          description "Interface handle";
        }
      }  // list interface-handle

      list weights-of-path {
        description "Paths Weights";
        leaf entry {
          type uint32;
          description "Paths Weights";
        }
      }  // list weights-of-path

      list adjacency-address {
        description "Adjacency address";
        uses FIB-ADDR-STR;
      }  // list adjacency-address

      list pbts-class-is-fallback-mapped {
        min-elements 9;
        max-elements 9;
        description
          "Does PBTS class fall back to drop or any class";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list pbts-class-is-fallback-mapped

      list pbts-fallback-to-drop {
        min-elements 9;
        max-elements 9;
        description
          "PBTS class falls back to drop";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list pbts-fallback-to-drop

      list tunnel-is-forward-class {
        min-elements 256;
        max-elements 256;
        description
          "Flag to indicate if the Tunnel is forward class";
        leaf entry {
          type boolean;
          description "Array entry.";
        }
      }  // list tunnel-is-forward-class
    }  // grouping FIB-SH-TBL-LOADINFO-INT

    grouping FIB-SH-TBL-LOADINFO-DET {
      description
        "Detailed load sharing information for FIB table
       entries";
      container load-informtion-internal-data {
        description "Loadinfo internal data";
        uses FIB-SH-TBL-LOADINFO-INT;
      }  // container load-informtion-internal-data

      leaf packets-through-load-information {
        type uint64;
        description
          "Packets through this loadinfo";
      }

      leaf bytes-through-load-information {
        type uint64;
        units "byte";
        description
          "Bytes through this loadinfo";
      }

      leaf total-packets-through-load-information {
        type uint64;
        description
          "Total packets through this loadinfo";
      }

      leaf total-bytes-through-load-information {
        type uint64;
        units "byte";
        description
          "Total bytes through this loadinfo";
      }

      leaf prefix-of-owner {
        type uint32;
        description "Owner's Prefix";
      }

      leaf mask-length-of-owner {
        type uint32;
        description
          "Owner Prefix Mask length";
      }

      leaf load-information-reference-count {
        type uint16;
        description
          "Loadinfo reference count";
      }

      leaf per-dest-load-sharing-flag {
        type boolean;
        description
          "Flag to indicate if the Per destination load
         sharing flag is enabled";
      }

      leaf load-information-owner-deleted-flag {
        type boolean;
        description
          "Flag to indicate if the Loadinfo owner deleted
         flag is enabled ";
      }

      leaf loadinfo-sanity-flag {
        type boolean;
        description
          "Flag to indicate if the Loadinfo sanity flag is
         enabled";
      }

      leaf is-owner {
        type boolean;
        description "Owner flag";
      }
    }  // grouping FIB-SH-TBL-LOADINFO-DET

    grouping FIB-SH-TBL-FIB-DET {
      description
        "Detailed FIB table entry information";
      container loadshare-information {
        description
          "Detailed Loadshare info";
        uses FIB-SH-TBL-LOADINFO-DET;
      }  // container loadshare-information

      leaf fib-entry-version {
        type uint32;
        description
          "FIB entry version number";
      }

      leaf per-prefix-accounting {
        type uint8;
        description "Per Prefix Accounting";
      }

      leaf load-sharing-type {
        type Fib-loadshare-show;
        description "Load sharing type";
      }

      leaf fib-entry-adjacency-type {
        type Fib-adjacency-show;
        description
          "FIB entry adjacency type";
      }

      leaf fib-protocol-type {
        type uint32;
        description "FIB Protocol type";
      }

      leaf afi-fib-protocol-type {
        type uint32;
        description "AFI FIB protocol type";
      }

      leaf aib-l3-address {
        type yang:hex-string;
        description "AIB L3 Address";
      }

      leaf adjacency-address-length {
        type uint32;
        description "ADJ ADDR LEN";
      }

      leaf adjacency-interface {
        type uint32;
        description "ADJ IFH";
      }

      leaf fib-special-nh-information-type {
        type uint32;
        description
          "FIB Special NHINFO Type";
      }

      leaf fib-entry-adjacency-address {
        type yang:hex-string;
        description "FIB entry adj address";
      }

      leaf fib-entry-adjacency-interface {
        type uint32;
        description
          "FIB entry adjacency interface";
      }

      leaf packets-through-fib-entry {
        type uint64;
        description
          "Packets through this FIB entry";
      }

      leaf bytes-through-fib-entry {
        type uint64;
        units "byte";
        description
          "Bytes through this FIB entry";
      }

      leaf detailed-prefix-length {
        type uint32;
        description "Prefix length";
      }

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

      leaf precedence-forpackets {
        type uint8;
        description
          "Precedence for packets to this entry";
      }

      leaf traffic-index-for-packets {
        type uint8;
        description
          "Traffic index for packets to this entry";
      }

      leaf switch-compontent-id {
        type uint32;
        description
          "Switch function compontent ID";
      }

      leaf fast-adjacency-flag {
        type boolean;
        description "Fast adjacency flag";
      }

      leaf illegal-fast-adjacency-flag {
        type boolean;
        description
          "Illegal fast adjacency flag";
      }

      leaf remote-adjacency-flag {
        type boolean;
        description "Remote adjacency flag";
      }

      leaf bgp-attribute-id {
        type uint32;
        description "BGP attribute id";
      }

      leaf bgp-local-attribute-id {
        type uint32;
        description "BGP local attribute id";
      }

      leaf bgp-attribute-local-preference {
        type uint32;
        description
          "BGP attribute local preference of the path";
      }

      leaf bgp-attribute-origin-as {
        type uint32;
        description
          "BGP attribute origin as";
      }

      leaf bgp-attribute-next-hop-as {
        type uint32;
        description
          "BGP attribute next hop as";
      }

      leaf path-string {
        type string;
        description "As path string";
      }

      leaf extcom-string {
        type yang:hex-string;
        description "extcom st";
      }

      leaf com-string {
        type yang:hex-string;
        description "com st";
      }

      leaf extended-community {
        type uint32;
        description "extended community";
      }

      leaf qos-group {
        type uint32;
        description
          "Quality of Service Group";
      }

      leaf mpls-fec {
        type uint32;
        description
          "MPLS forwarding equivalence class";
      }

      leaf qppb-qos-group-and-ip-precedence {
        type uint32;
        description
          "QPPB quality of service group and IP precedence";
      }

      leaf flow-tag {
        type uint8;
        description "PBR flow-tag";
      }

      leaf forward-class {
        type uint8;
        description
          "SPP forwarding class ID";
      }

      leaf pl-time-of-last-update-in-msec {
        type uint64;
        description
          "The time of last update for PL in msec";
      }

      leaf ldi-time-of-last-update-in-msec {
        type uint64;
        description
          "The time of last update for LDI in msec";
      }

      leaf lwldi-time-of-last-update-in-msec {
        type uint64;
        description
          "The time of last update for LW-LDI in msec";
      }

      leaf encap-id {
        type uint64;
        description "Prefix EncapID";
      }

      leaf pl-time-stamp-type {
        type uint32;
        description
          "The type of time-stamp on PL";
      }
    }  // grouping FIB-SH-TBL-FIB-DET

    grouping FIB-SH-TBL-FIB {
      description
        "Basic FIB table information";
      container detail-fib-entry-information {
        description
          "Detailed FIB entry information";
        uses FIB-SH-TBL-FIB-DET;
      }  // container detail-fib-entry-information

      container fib-entry-path {
        description "FIB entry path details";
        uses FIB-SH-TBL-PATH;
      }  // container fib-entry-path

      container srv6-endpoint {
        description
          "SRv6 Endpoint behavior (if applicable)";
        uses MGMT-SRV6-ENDPOINT-BEHAVIOR;
      }  // container srv6-endpoint

      leaf protocol-type-fib-entry {
        type uint32;
        description
          "Proto type for this entry";
      }

      leaf label-type {
        type string {
          length "0..16";
        }
        description "Local Label type";
      }

      leaf platform-hardware {
        type yang:hex-string;
        description "Platform Hardware info";
      }

      leaf number-of-referances-to-path-list {
        type uint32;
        description
          "Number of references to the pathlist";
      }

      leaf path-list-flags {
        type uint32;
        description "The pathlist flags";
      }

      leaf path-list-source {
        type uint32;
        description "The pathlist source";
      }

      leaf number-of-referances-to-ldi {
        type uint32;
        description
          "Number of references to the LDI";
      }

      leaf ldi-flags {
        type uint32;
        description "The LDI flags";
      }

      leaf flags-external-ldi {
        type uint32;
        description
          "The flags of ext assocaited with LDI ";
      }

      leaf pointer-external-ldi {
        type uint32;
        description
          "The pointer to the ext assocaited with LDI";
      }

      leaf exact-path-interface-handle {
        type uint32;
        description
          "exact-path interface handle";
      }

      leaf exact-path-gre-interface-handle {
        type uint32;
        description
          "exact-path GRE physical interface handle";
      }

      leaf exact-route-gre-phys-ifh-avail {
        type boolean;
        description
          "exact-route GRE phy ifh available";
      }

      leaf exact-route-result {
        type boolean;
        description "exact-route result";
      }

      leaf prefix-is-static-or-connected {
        type boolean;
        description
          "Prefix is static or connected";
      }

      leaf packet-should-recieve {
        type boolean;
        description
          "Packet should always be received";
      }

      leaf prefix-connected {
        type boolean;
        description "Prefix is connected";
      }

      leaf prefix-for-adjancency {
        type boolean;
        description
          "Prefix is for an adjacency";
      }

      leaf prefix-for-pic-next-hop {
        type boolean;
        description
          "Prefix is for a PIC nexthop";
      }

      leaf purgable-after-purge-interval {
        type boolean;
        description
          "Purgable after the purge interval";
      }

      leaf broadcast-recive-flag {
        type boolean;
        description "Broadcast receive flag";
      }

      leaf broadcast-forward-flag {
        type boolean;
        description "Broadcast forward flag";
      }

      leaf zero-by-zero-route-as-default {
        type boolean;
        description
          "0/0 route added as default route";
      }

      leaf external-switch-triggered {
        type boolean;
        description
          "External switch function triggered";
      }

      leaf route-attribute-flag {
        type boolean;
        description
          "Route attributes summary flag";
      }

      leaf dummy-real-zero-route {
        type boolean;
        description "Dummy real zero route";
      }

      leaf ldi-lw-flag {
        type uint32;
        description "The LDI LW flags";
      }

      leaf ref-counter-of-ldi-lw-ldi {
        type uint32;
        description
          "The refcounter of LDI LW LDI";
      }

      leaf type-of-ldi-lw-ldi {
        type uint32;
        description "The type of LDI LW LDI";
      }

      leaf lspa-flags {
        type uint32;
        description "The LSPA flags";
      }

      leaf version-of-route {
        type uint64;
        description
          "The version of the route";
      }

      leaf fib-route-download-priority {
        type uint32;
        description
          "Priority at which the route was downloaded";
      }

      leaf time-of-last-update-in-msec {
        type uint64;
        description
          "The time of last update in msec";
      }

      leaf l2-subscriber-route {
        type boolean;
        description "Is L2 Subscriber route";
      }

      leaf l2-subscriber-xconnect-id {
        type uint32;
        description
          "XConnect-id associated with L2 subscriber";
      }

      leaf l2-subscriber-flags {
        type uint32;
        description
          "Flags associated with L2 subscriber";
      }

      leaf l2-subscriber-ip-protocol {
        type uint32;
        description
          "IP protocol associated with L2 subscriber";
      }

      leaf l2tpv3-cookie-length-bits {
        type uint32;
        description
          "L2TPv3 cookie length for L2 subscriber";
      }

      leaf route-for-external-reach-linecard-flag {
        type boolean;
        description
          "Route destined for Line Card that support
         External Reach only";
      }

      leaf route-source-not-preferred {
        type boolean;
        description
          "The source of this route is not preferred over
         other sources with the same prefix";
      }

      leaf route-is-sr-flag {
        type boolean;
        description
          "Route is a MPLS Segment-Routing prefix";
      }

      leaf route-is-srv6-headend {
        type boolean;
        description
          "This route is an SRv6 Head-end";
      }

      leaf route-is-srv6-endpoint {
        type boolean;
        description
          "This route is an SRv6 Endpoint";
      }

      leaf internal-i-droute {
        type boolean;
        description "Internal ID route";
      }

      leaf internal-id-route-type {
        type string;
        description "Internal ID route type";
      }

      leaf prefix-is-in-oor-state {
        type boolean;
        description
          "prefix is not installed in HW as platform
         out-of-resource";
      }

      leaf ldi-base-extended-flags {
        type uint16;
        description
          "LDI Base Extended Flags";
      }

      leaf lwldi-base-extended-flags {
        type uint16;
        description
          "LWLDI Base Extended Flags";
      }

      list extension-object {
        description
          "Leaf Extension Object List";
        uses FIB-SH-TBL-FIB-EXT-CMN-DET;
      }  // list extension-object
    }  // grouping FIB-SH-TBL-FIB

    grouping FIB-RETRY-DB-INFO {
      description "FIB Retry DB information";
      leaf retry-flags {
        type uint32;
        description "FIB Retry flags";
      }

      leaf retry-count {
        type uint32;
        description "FIB Retry count";
      }

      leaf retry-object-info {
        type string;
        description "FIB Object String";
      }

      leaf retry-fib-object-type {
        type string;
        description "FIB Object type";
      }

      leaf retry-timestamp {
        type string;
        description "FIB Retry timestamp";
      }

      leaf retry-sched-class {
        type Fib-retry-entry-bag-sched-class;
        description
          "FIB Retry scheduling class";
      }
    }  // grouping FIB-RETRY-DB-INFO

    grouping FIB-SH-TIMESPEC {
      description "FIB SH TIMESPEC";
      leaf seconds {
        type int32;
        description "Seconds";
      }

      leaf nano-seconds {
        type int32;
        description "NanoSeconds";
      }
    }  // grouping FIB-SH-TIMESPEC

    grouping FIB-SH-FRR-LOG {
      description "FIB frr log information";
      container rrr-timestamp {
        description
          "FIB fast reroute timestamp";
        uses FIB-SH-TIMESPEC;
      }  // container rrr-timestamp

      leaf frr-protocol-type {
        type Fib-bag-protocol;
        description "FIB Protocol Type";
      }

      leaf frr-interface-name {
        type xr:Interface-name;
        description
          "Interface assoc w FRR nh";
      }

      leaf frr-prefix {
        type string {
          length "0..52";
        }
        description "nh prefix";
      }

      leaf frr-switching-time {
        type uint32;
        description
          "FIB fast reroute switching time";
      }

      leaf bundle-member-interface-name {
        type xr:Interface-name;
        description "bundle member";
      }
    }  // grouping FIB-SH-FRR-LOG

    grouping FIB-SH-TBL-EXT-PL-SUM {
      description
        "FIB external client pathlist summary";
      leaf sep-num-ecd-pathlist {
        type uint32;
        description
          "Number of ECD pathlists";
      }

      leaf sep-num-ecd-pl-unresolved {
        type uint32;
        description
          "Number of ECD pathlists unresolved";
      }

      list sep-num-ecd-pl-per-interest {
        max-elements 17;
        description
          "Number of ECD pathlists per interest";
        leaf entry {
          type uint32;
          description
            "Number of ECD pathlists per interest";
        }
      }  // list sep-num-ecd-pl-per-interest
    }  // grouping FIB-SH-TBL-EXT-PL-SUM

    grouping FIB-SH-TBL-EXT-SUM-ALL {
      description
        "FIB external brief summary information across all
       clients";
      container sesa-pl-sum {
        description
          "External pathlist summary";
        uses FIB-SH-TBL-EXT-PL-SUM;
      }  // container sesa-pl-sum

      leaf sesa-num-client {
        type uint32;
        description "Client information";
      }
    }  // grouping FIB-SH-TBL-EXT-SUM-ALL

    grouping FIB-OBJECT-MARKER-INFO {
      description
        "FIB Object Marker Information";
      container object-base {
        description "Object Base";
        uses FIB-SH-FIB-OBJ-BASE;
      }  // container object-base

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

      leaf active {
        type boolean;
        description "Enabled";
      }

      leaf need-timer {
        type boolean;
        description "Need Timer Support";
      }

      leaf need-wrap {
        type boolean;
        description "Need Wrap Support";
      }
    }  // grouping FIB-OBJECT-MARKER-INFO

    grouping FIB-OBJECT-QUEUE-INFO {
      description
        "FIB Object Queue Information";
      container object-base {
        description "Object Base";
        uses FIB-SH-FIB-OBJ-BASE;
      }  // container object-base

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

      leaf queue-id {
        type uint32;
        description "Queue ID";
      }

      leaf number-of-nodes {
        type uint32;
        description "Number of Nodes";
      }

      leaf number-of-special-nodes {
        type uint32;
        description
          "Number of Special Nodes";
      }

      list marker {
        description "Object Markers";
        uses FIB-OBJECT-MARKER-INFO;
      }  // list marker
    }  // grouping FIB-OBJECT-QUEUE-INFO

    grouping FIB-RSRC-BAG {
      description
        "Hardware object resource availability";
      leaf resource-name {
        type string;
        description "Resource Name";
      }

      leaf resource-mode {
        type Fib-rsrc-mode-bag;
        description "OOR mode for resource";
      }
    }  // grouping FIB-RSRC-BAG

    grouping FIB-SH-RSRC-AVAIL-STATE {
      description
        "FIB resource availability state";
      leaf resource-mode {
        type Fib-rsrc-mode-bag;
        description
          "Current overall OOR mode";
      }

      leaf hardware-resource-info {
        type yang:hex-string;
        description
          "Opaque hardware resource state info";
      }

      leaf shared-memory-oor-counter {
        type uint8;
        description
          "Shared memory OOR count";
      }

      leaf hardware-oor-counter {
        type uint8;
        description "Hardware OOR count";
      }

      leaf incoming-oor-timestamp {
        type uint64;
        description "Incoming OOR timestamp";
      }

      leaf outgoing-oor-timestamp {
        type uint64;
        description "Outgoing OOR timestamp";
      }

      list shared-memory-status {
        description
          "Current status of shared memory windows";
        uses FIB-SH-RSRC-SHM;
      }  // list shared-memory-status

      list hardware-resource-mode {
        description
          "Hardware object resource mode";
        uses FIB-RSRC-BAG;
      }  // list hardware-resource-mode
    }  // grouping FIB-SH-RSRC-AVAIL-STATE

    grouping FIB-GENERIC-INTF-LIST-DATA {
      description
        "Data related to generic interface list";
      leaf ild-name {
        type string {
          length "0..33";
        }
        description "Interface_list name";
      }

      leaf ild-id {
        type uint32;
        description "Interface_list id";
      }

      leaf ild-ptr {
        type uint32;
        description "Address of struct";
      }

      leaf ild-flag {
        type uint32;
        description "Flags";
      }

      leaf ild-refcount {
        type uint32;
        description "Ref count";
      }

      leaf ild-ts {
        type uint64;
        description
          "Last updated time stamp";
      }

      leaf ild-interface-count {
        type uint32;
        description
          "Total interfaces in the list";
      }

      list ild-ifh {
        description
          "Array of members' IFhandle";
        leaf entry {
          type xr:Interface-name;
          description
            "Array of members' IFhandle";
        }
      }  // list ild-ifh
    }  // grouping FIB-GENERIC-INTF-LIST-DATA

    grouping FIB-SH-PFX-MASKLEN-CNT {
      description
        "FIB Prefix Masklength counts";
      leaf mask-length {
        type uint8;
        description "FIB Prefix Mask length";
      }

      leaf number-of-prefixes {
        type uint32;
        description
          "Number of prefixes with given mask length";
      }
    }  // grouping FIB-SH-PFX-MASKLEN-CNT

    grouping FIB-SH-PFX-MASKLEN-DISTRIB {
      description
        "FIB Prefix Masklengths distribution";
      list unicast-prefixe {
        description
          "Masklength counts for unicast prefixes";
        uses FIB-SH-PFX-MASKLEN-CNT;
      }  // list unicast-prefixe

      list broadcast-prefixe {
        description
          "Masklength counts for broadcast prefixes";
        uses FIB-SH-PFX-MASKLEN-CNT;
      }  // list broadcast-prefixe

      list multicast-prefix {
        description
          "Masklength counts for multicast prefixes";
        uses FIB-SH-PFX-MASKLEN-CNT;
      }  // list multicast-prefix
    }  // grouping FIB-SH-PFX-MASKLEN-DISTRIB

    grouping FIB-PL-LDI-COUNT {
      description
        "FIB Pathlist and Loadinfo summary";
      leaf total-load-sharing-element-bytes {
        type uint32;
        units "byte";
        description
          "Total memory used by load sharing elements in
         bytes";
      }

      leaf total-load-sharing-element-references {
        type uint64;
        description
          "Total count of references to load sharing
         elements";
      }

      leaf total-path-list-elements {
        type uint32;
        description
          "Total count of Pathlist elements";
      }

      leaf recursive-path-list-elements {
        type uint32;
        description
          "Count of recursive Pathlist elements";
      }

      leaf platform-shared-path-list-elements {
        type uint32;
        description
          "Count of platform shared Pathlist elements";
      }

      leaf retry-path-list-elements {
        type uint32;
        description
          "Count of Pathlist elements in retry";
      }

      leaf total-load-info-elements {
        type uint32;
        description
          "Total count of Loadinfo elements";
      }

      leaf recursive-load-info-elements {
        type uint32;
        description
          "Count of recursive Loadinfo elements";
      }

      leaf platform-shared-load-info-elements {
        type uint32;
        description
          "Count of platform shared Loadinfo elements";
      }

      leaf xpl-load-info-elements {
        type uint32;
        description
          "Count of XPL Loadinfo elements";
      }
    }  // grouping FIB-PL-LDI-COUNT

    grouping FIB-SH-SUM {
      description "FIB summary statistics";
      container exclusive-load-sharing-element {
        description
          "Exclusive load sharing element";
        uses FIB-PL-LDI-COUNT;
      }  // container exclusive-load-sharing-element

      container shared-load-sharing-element {
        description
          "Shared load sharing element";
        uses FIB-PL-LDI-COUNT;
      }  // container shared-load-sharing-element

      container cross-shared-load-sharing-element {
        description
          "Cross-table shared load sharing element";
        uses FIB-PL-LDI-COUNT;
      }  // container cross-shared-load-sharing-element

      container encap-shared-load-sharing-element {
        description
          "Encap-shared load sharing element";
        uses FIB-PL-LDI-COUNT;
      }  // container encap-shared-load-sharing-element

      container prefix-masklen-distribution {
        description
          "Distribution of prefix mask lengths";
        uses FIB-SH-PFX-MASKLEN-DISTRIB;
      }  // container prefix-masklen-distribution

      leaf prefix {
        type yang:hex-string;
        description "The router-id";
      }

      leaf ss-tbl-id {
        type uint32;
        description "Table Id";
      }

      leaf ss-tbl-id-ptr {
        type uint32;
        description "Table Id Ptr";
      }

      leaf ss-vrf-id {
        type uint32;
        description
          "Virtual routing forwarding instance Id";
      }

      leaf ss-vr-id {
        type uint32;
        description
          "Virtual router instance Id";
      }

      leaf load-balancing {
        type Ss-lba-state;
        description
          "LBA configuration state";
      }

      leaf forwarding-elements {
        type uint32;
        description
          "Number of forwarding elements linked to the
         table";
      }

      leaf routes {
        type uint32;
        description "Number of routes";
      }

      leaf prefix-in-place-modifications {
        type uint32;
        description
          "Number of inplace modifications";
      }

      leaf stale-prefix-deletes {
        type uint32;
        description
          "Number of deleted stale leafs";
      }

      leaf load-sharing-elements {
        type uint32;
        description
          "Count of load sharing elements";
      }

      leaf load-sharing-references {
        type uint64;
        description
          "Count of load sharing references";
      }

      leaf total-load-share-element-bytes {
        type uint32;
        description
          "Total memory used by load sharing elements";
      }

      leaf leaves-used-bytes {
        type uint32;
        description
          "Total memory used by leaves";
      }

      leaf reresolve-entries {
        type uint32;
        description
          "Number of reresolved entries";
      }

      leaf old-unresolve-entries {
        type uint32;
        description
          "Number of old unresolved entries";
      }

      leaf new-unresolve-entries {
        type uint32;
        description
          "Number of new unresolved entries";
      }

      leaf unresolve-entries {
        type uint32;
        description
          "Number of total unresolved entries";
      }

      leaf cef-route-drops {
        type uint32;
        description
          "Number of routes dropped by CEF";
      }

      leaf cef-version-mismatch-route-drops {
        type uint64;
        description
          "the number of routes dropped due to version
         mismatch";
      }

      leaf delete-cache-num-entries {
        type uint32;
        description
          "Number of entries in the route delete cache";
      }

      leaf existing-leaves-revisions {
        type uint32;
        description
          "Number of entries present on addition";
      }

      leaf fib-default-prefix {
        type uint32;
        description "Default prefix";
      }

      leaf fib-default-prefix-mask-length {
        type uint32;
        description
          "Default prefix mask length";
      }

      leaf next-hops {
        type uint32;
        description "Number of NHINFOS";
      }

      leaf incomplete-next-hops {
        type uint32;
        description
          "Number of incomplete NHINFOS";
      }

      leaf resolution-timer {
        type uint32;
        units "second";
        description
          "IP CEF resolution timer in seconds";
      }

      leaf slow-process-timer {
        type uint32;
        units "second";
        description
          "IP CEF slow processing time in seconds";
      }

      leaf max-resolution-timer {
        type uint32;
        units "second";
        description
          "IP CEF max resolution time in seconds";
      }

      leaf imposition-prefixes {
        type uint32;
        description
          "Number of prefixes with imposition LDI";
      }

      leaf extended-prefixes {
        type uint32;
        description
          "Number of prefixes with extended path-list";
      }

      leaf cefl-bl-recycled-routes {
        type uint32;
        description
          "Number of routes updates with recycled label
         handled";
      }

      leaf ldi-backwalks {
        type uint32;
        description
          "pd backwalks on LDI modify with backup path";
      }

      leaf ss-prot-route-count {
        type uint32;
        description
          "Number of routes with FRR protection";
      }

      leaf lisp-eid-prefixes {
        type uint32;
        description
          "Number of lisp eid prefixes associated with
         table";
      }

      leaf lisp-eid-valid-prefixes {
        type uint32;
        description
          "Number of lisp eid prefixes eligible for
         forwarding";
      }

      leaf lisp-rloc-objects {
        type uint32;
        description
          "Number of lisp rloc objects associated with
         table";
      }

      leaf number-routes-srv6-headend {
        type uint32;
        description
          "Number of SRv6 headend routes";
      }

      leaf number-routes-srv6-endpoint {
        type uint32;
        description
          "Number of SRv6 endpoint routes";
      }

      leaf number-of-sr-labels {
        type uint32;
        description "Number of SR labels";
      }

      leaf ss-drop-pl-count {
        type uint32;
        description
          "Number of dropped pathlists";
      }
    }  // grouping FIB-SH-SUM

    grouping FIB-AIB-EOD-RECVD-TS {
      description
        "FIB AIB EOD received timestamp";
      leaf aib-type {
        type Fib-aib-adjacency;
        description "AIB requested type";
      }

      leaf aib-adjacency-flags {
        type uint32;
        description
          "AIB adjacency request flags";
      }

      leaf aibeod-timestamp {
        type string;
        description "AIB EOD Timestamp";
      }

      leaf aib-register-timestamp {
        type string;
        description "AIB Register Timestamp";
      }
    }  // grouping FIB-AIB-EOD-RECVD-TS

    grouping FIB-AIB-EOD-RECVD-TS-AFI {
      description
        "FIB AIB EOD timestamp per AFI";
      leaf aibeodafi {
        type Fib-bag-protocol;
        description
          "FIB AIB EOD Address Family";
      }

      list aibeodtx-timestamp {
        description "FIB AIB Tx EODs";
        uses FIB-AIB-EOD-RECVD-TS;
      }  // list aibeodtx-timestamp

      list aibeodrx-timestamp {
        description "FIB AIB Rx EODs";
        uses FIB-AIB-EOD-RECVD-TS;
      }  // list aibeodrx-timestamp
    }  // grouping FIB-AIB-EOD-RECVD-TS-AFI

    grouping FIB-ISSU-PROTO-STATE {
      description "FIB ISSU protocol state";
      leaf protocol-name {
        type string {
          length "0..6";
        }
        description "FIB ISSU Protocol name";
      }

      leaf rsi-eod-valid {
        type boolean;
        description "RSI EOD expected/valid";
      }

      leaf rsi-eod-time-stamp {
        type string {
          length "0..33";
        }
        description
          "RSI EOD received timestamp";
      }

      leaf lsd-eod-valid {
        type boolean;
        description "LSD EOD expected/valid";
      }

      leaf lsd-eod-time-stamp {
        type string {
          length "0..33";
        }
        description
          "LSD EOD received timestamp";
      }

      leaf lmrib-eod-valid {
        type boolean;
        description
          "LMRIB EOD expected/valid";
      }

      leaf lmrib-eod-time-stamp {
        type string {
          length "0..33";
        }
        description
          "LMRIB EOD received timestamp";
      }

      leaf rib-info-valid {
        type boolean;
        description "RIB table info valid";
      }

      leaf bcdl-tables {
        type uint32;
        description "Number of BCDL tables";
      }

      leaf converged-tables {
        type uint32;
        description
          "Number of tables converged";
      }

      leaf rib-tables-converged-time-stamp {
        type string {
          length "0..33";
        }
        description
          "The converged timestamp for all rib tables";
      }

      leaf protocol-eod-valid {
        type boolean;
        description
          "Protocol EOD expected/valid";
      }

      leaf protocol-eod-time-stamp {
        type string {
          length "0..33";
        }
        description
          "Protocol EOD sent timestamp";
      }

      list aibeodafi-timestamp {
        description "FIB AIB EODs";
        uses FIB-AIB-EOD-RECVD-TS-AFI;
      }  // list aibeodafi-timestamp
    }  // grouping FIB-ISSU-PROTO-STATE

    grouping FIB-ISSU-STATE {
      description "FIB ISSU state";
      leaf imdr-support {
        type boolean;
        description "IMDR supported";
      }

      leaf slc-support {
        type boolean;
        description "SLC supported";
      }

      leaf fis-issu-restart {
        type boolean;
        description "ISSU restart";
      }

      leaf imdr-eoc-implicit {
        type boolean;
        description
          "IMDR End-of-config implicit";
      }

      leaf slc-eoc-implicit {
        type boolean;
        description
          "SLC End-of-config implicit";
      }

      leaf eoc-received-imdr-time-stamp {
        type string {
          length "0..33";
        }
        description
          "End-of-config received from IMDR timestamp";
      }

      leaf eoc-received-slc-time-stamp {
        type string {
          length "0..33";
        }
        description
          "End-of-config received from SLC timestamp";
      }

      leaf eod-received-im-time-stamp {
        type string {
          length "0..33";
        }
        description
          "End-of-download received from IM timestamp";
      }

      leaf eod-sent-imdr-time-stamp {
        type string {
          length "0..33";
        }
        description
          "End-of-download send to IMDR timestamp";
      }

      leaf eod-sent-slc-time-stamp {
        type string {
          length "0..33";
        }
        description
          "End-of-download send to SLC timestamp";
      }

      leaf fis-issu-error-ts {
        type uint64;
        description
          "ISSU error sent to ISSUMGR timetstamp";
      }

      list fis-proto-state {
        max-elements 3;
        description
          "IMDR state for the protocols";
        uses FIB-ISSU-PROTO-STATE;
      }  // list fis-proto-state
    }  // grouping FIB-ISSU-STATE

    grouping FIB-RSRC-OOR-BAG {
      description
        "Hardware object resource out of resource";
      leaf oor-resource-name {
        type string;
        description "OOR resource name";
      }

      leaf oor-resource-mode {
        type Fib-rsrc-mode-bag;
        description "OOR mode for resource";
      }

      leaf oor-resource-counter {
        type uint32;
        description "Object OOR counters";
      }
    }  // grouping FIB-RSRC-OOR-BAG

    grouping FIB-SH-RSRC-SHM {
      description
        "Shared memory availability";
      leaf shared-memory-window {
        type Fib-bag-shmwin;
        description
          "Shared Memory Window Type";
      }

      leaf resource-mode {
        type Fib-rsrc-mode-bag;
        description
          "OOR mode for this shared memory window";
      }

      leaf average-bytes-available {
        type uint64;
        units "byte";
        description
          "Average number of bytes available";
      }

      leaf maximum-bytes-available {
        type uint64;
        units "byte";
        description
          "Maximum bytes available";
      }
    }  // grouping FIB-SH-RSRC-SHM

    grouping FIB-SH-RSRC-AVAIL-OOR-STATE {
      description
        "FIB resource availability state";
      list shared-memory-status {
        description
          "Shared memory out of resource";
        uses FIB-SH-RSRC-SHM;
      }  // list shared-memory-status

      list hardware-resource-mode {
        description
          "Hardware objects resource out of resource";
        uses FIB-RSRC-OOR-BAG;
      }  // list hardware-resource-mode
    }  // grouping FIB-SH-RSRC-AVAIL-OOR-STATE

    grouping FIB-SH-FIB-OBJ-BASE {
      description
        "FIB object base information";
      leaf object-reference-count {
        type uint32;
        description
          "FIB Object Reference Count";
      }

      leaf object-flags {
        type uint32;
        description "FIB Object flags";
      }

      leaf object-type {
        type uint8;
        description "FIB Object type";
      }

      leaf object-time-stamp {
        type uint64;
        description
          "FIB Object TimeStamp in msec";
      }

      leaf object-pointer {
        type uint64;
        description "FIB Object pointer";
      }
    }  // grouping FIB-SH-FIB-OBJ-BASE
  }  // submodule Cisco-IOS-XR-fib-common-oper-sub4