module Cisco-IOS-XR-ipv4-bgp-oper {

    yang-version 1;

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

    prefix ipv4-bgp-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }
    import Cisco-IOS-XR-ipv4-bgp-datatypes {
      prefix dt1;
    }

    include Cisco-IOS-XR-ipv4-bgp-oper-sub1 {
      revision-date "2021-05-10";
    }

    organization "Cisco Systems, Inc.";

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

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR ipv4-bgp package operational data.
     
     This module contains definitions
     for the following management objects:
       bgp: BGP operational data
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-05-10" {
      description
        "Added platform capability mix srte CLI
       2021-03-15
         Added Export Allow Config for backup
       2021-03-05
         Deprecated Hidden commands
       2021-03-05
         Added SR Policy Path Prefernce in Bestpath Compare
       2020-10-04
         Added Soft NextHop Validation and Metric
       2020-09-30
         Added LATEST bestpath comparison reason
       2020-09-18
         Added SRv6 TE BSID information
       2020-07-15
         Changed VRFDBVRFTable pathformat";
    }

    revision "2020-06-23" {
      description
        "changed the afi from integer to string in BPM entities
       2020-03-30
       Extended flags to 16 bits and changed leaf names as per convention";
    }

    revision "2020-01-11" {
      description
        "Fixing invalid range for prefix length.
       2019-08-31
       Fixing revision error in module.";
    }

    revision "2019-04-05" {
      description
        "Fixing backward compatibility error in module";
    }

    revision "2019-04-05" {
      description
        "Added schema for opercoverage missing paths";
    }

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

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

    revision "2017-06-26" {
      description
        "Change identifiers to be more readable.";
    }

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

    revision "2015-08-27" {
      description "IOS XR 5.3.2 revision.";
    }

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

    typedef Bgp-rpki-edm-af {
      type enumeration {
        enum "ipv4" {
          value 2;
          description "IPv4";
        }
        enum "ipv6" {
          value 10;
          description "IPv6";
        }
      }
      description "Bgp rpki edm af";
    }

    typedef Bgp-epe-obj {
      type union {
        type enumeration {
          enum "epe-peer-type" {
            value 1;
            description
              "Peer as an EPE object";
          }
          enum "epe-peer-set-type" {
            value 2;
            description
              "Peer-Set as an EPE object";
          }
          enum "epe-adjacency-type" {
            value 3;
            description
              "Firsthop Adjacency as an EPE object";
          }
        }
        type uint32 {
          range "1..3";
        }
      }
      description "Bgp epe obj";
    }

    typedef Bgp-route {
      type enumeration {
        enum "used" {
          value 0;
          description
            "Used path from neighbor";
        }
        enum "received-only" {
          value 1;
          description
            "Received only path from neighbor";
        }
        enum "safi-labeled-unicast-used" {
          value 2;
          description
            "Used path from neighbor received via
           labeled-unicast SAFI";
        }
        enum
          "safi-labeled-unicast-received-only" {
          value 3;
          description
            "Received only path from neighbor received via
           labeled-unicast SAFI";
        }
        enum "rib" {
          value 4;
          description
            "Redistributed from the RIB";
        }
        enum "aggregate" {
          value 5;
          description
            "Locally generated aggregate";
        }
      }
      description "Bgp route";
    }

    typedef Bgp-entity {
      type enumeration {
        enum "af-group" {
          value 0;
          description "Address family group";
        }
        enum "session-group" {
          value 1;
          description
            "BGP Peer Session group";
        }
        enum "neighbor-group" {
          value 2;
          description "BGP Peer group";
        }
        enum "neighbor" {
          value 3;
          description "BGP Neighbor";
        }
      }
      description "Bgp entity";
    }

    typedef Bgp-route-distinguisher {
      type string;
      description "Bgp route distinguisher";
    }

    grouping UPDATE-GENERATION-PROCESS {
      description
        "Common node of instance-active, instance-standby";
      container update-generation-process {
        description
          "The BGP Update generate table for the process";
        uses BGP-UPDGEN-PROC-BAG;
      }  // container update-generation-process
    }  // grouping UPDATE-GENERATION-PROCESS

    grouping VRFDBVR-FENTRY {
      description
        "Common node of instance-active, instance-standby";
      container vrfdbvr-fentry {
        description "A BGP VRF DB VRF entry";
        uses BGP-VRF-DB-VRF-TBL-BAG;
      }  // container vrfdbvr-fentry
    }  // grouping VRFDBVR-FENTRY

    grouping PATH {
      description
        "Common node of path-table, path-used-table,
       path-labeled-table";
      list path {
        description "A BGP path table entry";
        leaf rd {
          type Bgp-route-distinguisher;
          description
            "Route Distinguisher value";
        }

        leaf network {
          type xr:Cisco-ios-xr-string;
          description
            "Network prefix in dotted decimal format for ip
           prefix, else in hex string format";
        }

        leaf prefix-length {
          type uint32;
          description
            "Length of the subnet prefix";
        }

        leaf neighbor-address {
          type inet:ip-address-no-zone;
          description
            "IPv4 or IPv6 Address for the BGP neighbor";
        }

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

        leaf source-rd {
          type Bgp-route-distinguisher;
          description
            "Source Route Distinguisher value";
        }

        leaf orig-source-rd {
          type Bgp-route-distinguisher;
          description
            "Original Source Route Distinguisher";
        }

        leaf path-id {
          type uint32 {
            range "0..4294967295";
          }
          description "Received Path ID";
        }

        uses BGP-PATH-BAG;
      }  // list path
    }  // grouping PATH

    grouping BMP {
      description
        "Common node of default-vrf, vrf";
      container bmp {
        description
          "BMP related Operational Data";
        container server-summaries {
          description "Table of BMP Servers";
          list server-summary {
            key "server-id";
            description
              "Summary Information about BMP server";
            leaf server-id {
              type uint32 {
                range "1..8";
              }
              description "BMP Server ID";
            }

            uses BGP-BMP-SRVR-BAG;
          }  // list server-summary
        }  // container server-summaries

        container server-neighbors {
          description
            "Table of Neighbors for a BMP Server";
          list server-neighbor {
            key "server-id";
            description
              "BMP Server under which neighbor info are
             needed";
            container monitored-neighbors {
              description
                "List of Neighbors under which BMP Server is
               configured";
              list monitored-neighbor {
                description
                  "Information about a neighbor monitored by
                 BMP server";
                leaf neighbor-address {
                  type inet:ip-address-no-zone;
                  description
                    "IPv4 or IPv6 Address of the BGP Neighbor";
                }

                leaf vrf-name {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Name of VRF, the neighbor belongs to";
                }

                uses BGP-BMP-NBR-BAG;
              }  // list monitored-neighbor
            }  // container monitored-neighbors

            leaf server-id {
              type uint32 {
                range "1..8";
              }
              description "BMP Server ID";
            }
          }  // list server-neighbor
        }  // container server-neighbors
      }  // container bmp
    }  // grouping BMP

    grouping VRFDBVRF-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container vrfdbvrf-table-entries {
        description
          "A BGP VRF DB VRFs table";
        list vrfdbvrf-table-entry {
          description
            "A BGP VRF DB VRF TABLE";
          leaf index {
            type uint32;
            description
              "BGP VRF DB TBL index";
          }

          leaf id {
            type uint32;
            description "BGP VRF DB TBL ID";
          }

          uses BGP-VRF-DB-VRF-TBL-BAG;
        }  // list vrfdbvrf-table-entry
      }  // container vrfdbvrf-table-entries
    }  // grouping VRFDBVRF-TABLE

    grouping ATTRIBUTE-FILTER-GROUP-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container attribute-filter-groups {
        description
          "All attribute-filter groups in this instance";
        list attribute-filter-group {
          key "group-name";
          description
            "The BGP Attribute filter group Table Entry";
          leaf group-name {
            type xr:Cisco-ios-xr-string;
            description
              "The BGP Attribute filter group table entry
             name";
          }

          uses BGP-ATTRFILTER-GROUP-BAG;
        }  // list attribute-filter-group
      }  // container attribute-filter-groups
    }  // grouping ATTRIBUTE-FILTER-GROUP-TABLE

    grouping ATTRIBUTE-TABLE {
      description
        "Common node of instance-active, instance-standby,
       af";
      container attributes {
        description
          "The BGP Attribute table";
        list attribute {
          description
            "A BGP Attribute table entry";
          leaf attribute-iid {
            type uint32 {
              range "0..255";
            }
            description
              "Identifier of BGP Attribute table entry";
          }

          leaf attribute-cache-bucket {
            type uint32 {
              range "0..65535";
            }
            description
              "Cache bucket value of BGP Attribute table
             entry";
          }

          leaf attribute-cache-id {
            type uint32;
            description
              "Identifier of the BGP Attribute Cache";
          }

          uses BGP-ATTR-BAG;
        }  // list attribute
      }  // container attributes
    }  // grouping ATTRIBUTE-TABLE

    grouping SESSION-TABLE {
      description
        "Common node of default-vrf, vrf";
      container sessions {
        description "The BGP session table";
        list session {
          key "neighbor-address";
          description
            "A BGP session table entry";
          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          uses BGP-NBR-BRIEF-BAG;
        }  // list session
      }  // container sessions
    }  // grouping SESSION-TABLE

    grouping POSTIT-TABLE {
      description
        "Common node of default-vrf, vrf";
      container postits {
        description "The BGP Neighbor table";
        list postit {
          key "neighbor-address";
          description
            "A BGP Postit table entry";
          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          uses BGP-NEIGHBOR-NSR-BAG;
        }  // list postit
      }  // container postits
    }  // grouping POSTIT-TABLE

    grouping UPDATE-INBOUND-ERROR-PROCESS {
      description
        "Common node of instance-active, instance-standby";
      container update-inbound-error-process {
        description
          "Update inbound error information for the process";
        uses BGP-UPDERR-PROC-BAG;
      }  // container update-inbound-error-process
    }  // grouping UPDATE-INBOUND-ERROR-PROCESS

    grouping NEXT-HOP-VRF {
      description
        "Common node of default-vrf, vrf";
      container next-hop-vrf {
        description
          "A BGP Next-hop VRF table entry";
        uses BGP-NEXTHOP-VRF-BAG;
      }  // container next-hop-vrf
    }  // grouping NEXT-HOP-VRF

    grouping RPKI-SUMMARY {
      description
        "Common node of instance-active, instance-standby";
      container rpki-summary {
        description "RPKI Summary Info";
        uses BGP-RPKI-SUMMARY-BAG;
      }  // container rpki-summary
    }  // grouping RPKI-SUMMARY

    grouping VRF-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container vrfs {
        description
          "VRF related operational data";
        list vrf {
          key "vrf-name";
          description
            "Operational data for a particular VRF";
          leaf vrf-name {
            type xr:Cisco-ios-xr-string;
            description "Name of the VRF";
          }

          uses UPDATE-INBOUND-ERROR-VRF;

          uses AF-TABLE;

          uses INFORMATION;

          uses UPDATE-INBOUND-FILTER-VRF;

          uses POSTIT-TABLE;

          uses GLOBAL-PROCESS-INFO;

          uses UPDATE-INBOUND-ERROR-NEIGHBOR-TABLE;

          uses UPDATE-INBOUND-FILTER-NEIGHBOR-TABLE;

          uses BMP;

          uses NEIGHBOR-MISSING-EOR-TABLE;

          uses PROCESS-INFO;

          uses SESSION-TABLE;

          uses NEIGHBOR-TABLE;

          uses NEXT-HOP-VRF;

          uses NEIGHBOR-RANGE-TABLE;

          uses MESSAGE-LOG-TABLE;
        }  // list vrf
      }  // container vrfs
    }  // grouping VRF-TABLE

    grouping UPDATE-INBOUND-FILTER-VRF {
      description
        "Common node of default-vrf, vrf";
      container update-inbound-filter-vrf {
        description
          "Update inbound filtering information for the VRF";
        uses BGP-UPDFILTER-VRF-BAG;
      }  // container update-inbound-filter-vrf
    }  // grouping UPDATE-INBOUND-FILTER-VRF

    grouping INFORMATION {
      description
        "Common node of default-vrf, vrf";
      container information {
        description "Meta data for VRF";
        uses BGP-VRF-INFO-BAG;
      }  // container information
    }  // grouping INFORMATION

    grouping ENTITY-CONFIGURATION-TABLE {
      description
        "Common node of config-instance-default-vrf,
       config-vrf";
      container entity-configurations {
        description
          "The BGP Entity Configuration table";
        list entity-configuration {
          description
            "A BGP Entity Configuration table entry";
          leaf entity-type {
            type Bgp-entity;
            description
              "Type of the Entity configuration  table entry";
          }

          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          leaf entity-name {
            type xr:Cisco-ios-xr-string;
            description
              "Name of the Entity configuration table entry";
          }

          leaf length {
            type uint32 {
              range "0..128";
            }
            description
              "Length of the subnet prefix";
          }

          uses BGP-CONFIG-ENTITY-BAG;
        }  // list entity-configuration
      }  // container entity-configurations
    }  // grouping ENTITY-CONFIGURATION-TABLE

    grouping DEFAULT-VRF {
      description
        "Common node of instance-active, instance-standby";
      container default-vrf {
        description
          "Default VRF related operational data";
        uses UPDATE-INBOUND-ERROR-VRF;

        uses AF-TABLE;

        uses INFORMATION;

        uses UPDATE-INBOUND-FILTER-VRF;

        uses POSTIT-TABLE;

        uses GLOBAL-PROCESS-INFO;

        uses UPDATE-INBOUND-ERROR-NEIGHBOR-TABLE;

        uses UPDATE-INBOUND-FILTER-NEIGHBOR-TABLE;

        uses BMP;

        uses NEIGHBOR-MISSING-EOR-TABLE;

        uses PROCESS-INFO;

        uses SESSION-TABLE;

        uses NEIGHBOR-TABLE;

        uses NEXT-HOP-VRF;

        uses NEIGHBOR-RANGE-TABLE;

        uses MESSAGE-LOG-TABLE;
      }  // container default-vrf
    }  // grouping DEFAULT-VRF

    grouping UPDATE-INBOUND-ERROR-VRF {
      description
        "Common node of default-vrf, vrf";
      container update-inbound-error-vrf {
        description
          "Update inbound error information for the VRF";
        uses BGP-UPDERR-VRF-BAG;
      }  // container update-inbound-error-vrf
    }  // grouping UPDATE-INBOUND-ERROR-VRF

    grouping UPDATE-INBOUND-FILTER-NEIGHBOR-TABLE {
      description
        "Common node of default-vrf, vrf";
      container update-inbound-filter-neighbors {
        description
          "Update inbound filtering information for all
         neighbors";
        list update-inbound-filter-neighbor {
          key "neighbor-address";
          description
            "Update inbound filtering information for
           neighbor";
          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          uses BGP-UPDFILTER-NBR-BAG;
        }  // list update-inbound-filter-neighbor
      }  // container update-inbound-filter-neighbors
    }  // grouping UPDATE-INBOUND-FILTER-NEIGHBOR-TABLE

    grouping NEIGHBOR-RANGE-TABLE {
      description
        "Common node of default-vrf, vrfCommon node of
       default-vrf, vrf";
      container neighbor-ranges {
        description
          "The BGP Dynamic Neighbor Range table";
        list neighbor-range {
          key "neighbor-range-address";
          description
            "A BGP Neighbor Range table entry";
          leaf neighbor-range-address {
            type inet:ip-prefix;
            description
              "Neighbor Range prefix";
          }

          uses BGP-NBR-RANGE-BAG;
        }  // list neighbor-range
      }  // container neighbor-ranges
    }  // grouping NEIGHBOR-RANGE-TABLE

    grouping CONFIGURATION-USER-TABLE {
      description
        "Common node of config-instance-default-vrf,
       config-vrf";
      container configuration-users {
        description
          "The BGP configuration users table";
        list configuration-user {
          description
            "A BGP configuration user table entry";
          leaf entity-type {
            type Bgp-entity;
            description
              "Type of the configuration user table entry";
          }

          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          leaf entity-name {
            type xr:Cisco-ios-xr-string;
            description
              "Name of the configuration user table entry";
          }

          leaf length {
            type uint32 {
              range "0..128";
            }
            description
              "Length of the subnet prefix";
          }

          uses BGP-CONFIG-RELATIVES-BAG;
        }  // list configuration-user
      }  // container configuration-users
    }  // grouping CONFIGURATION-USER-TABLE

    grouping NEIGHBOR {
      description
        "Common node of neighbors, neighbor-af-table,
       neighbor-missing-eor-table";
      list neighbor {
        key "neighbor-address";
        description
          "A BGP Neighbor table entry";
        leaf neighbor-address {
          type inet:ip-address-no-zone;
          description
            "IPv4 or IPv6 Address of the BGP Neighbor";
        }

        uses BGP-NBR-BAG;
      }  // list neighbor
    }  // grouping NEIGHBOR

    grouping RT-HASH-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container rt-hash-table-entries {
        description
          "BGP Route Target Hash Table";
        list rt-hash-table-entry {
          description
            "BGP Route Target Hash Table Entry";
          leaf imp-exp {
            type uint32 {
              range "0..1";
            }
            description
              "Flag to indicate RT import or export";
          }

          leaf af-name {
            type dt1:Bgp-address-family;
            description "Address family";
          }

          leaf rt-hash {
            type uint32;
            description
              "Route Target Hash Index";
          }

          uses BGP-VRF-RT-HASH-SLICE-BAG;
        }  // list rt-hash-table-entry
      }  // container rt-hash-table-entries
    }  // grouping RT-HASH-TABLE

    grouping UPDATE-INBOUND-ERROR-NEIGHBOR-TABLE {
      description
        "Common node of default-vrf, vrf";
      container update-inbound-error-neighbors {
        description
          "Update inbound error information for all
         neighbors";
        list update-inbound-error-neighbor {
          key "neighbor-address";
          description
            "Update inbound error information for neighbor";
          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          uses BGP-UPDERR-NBR-BAG;
        }  // list update-inbound-error-neighbor
      }  // container update-inbound-error-neighbors
    }  // grouping UPDATE-INBOUND-ERROR-NEIGHBOR-TABLE

    grouping RPKI-SERVER-LIST {
      description
        "Common node of instance-active, instance-standby";
      container rpki-server-list {
        description "RPKI Server Table";
        uses BGP-RPKI-CACHES-BAG;
      }  // container rpki-server-list
    }  // grouping RPKI-SERVER-LIST

    grouping GLOBAL-PROCESS-INFO {
      description
        "Common node of default-vrf, vrf";
      container global-process-info {
        description
          "The Global Process information table";
        uses BGP-GLOBAL-PROCESS-INFO-BAG;
      }  // container global-process-info
    }  // grouping GLOBAL-PROCESS-INFO

    grouping RT-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container rt-entries {
        description
          "BGP Route Target Sets Table";
        list rt-entry {
          description
            "BGP Route Target Set Entry";
          leaf route-target-lower-bytes {
            type uint32;
            description
              "Lower 4 bytes of RT";
          }

          leaf route-target-upper-bytes {
            type uint32;
            description
              "Upper 4 bytes of RT";
          }

          leaf af-name {
            type dt1:Bgp-address-family;
            description "Address family";
          }

          leaf request-id {
            type uint32;
            description "Random Request ID";
          }

          uses BGP-VRF-RT-BAG;
        }  // list rt-entry
      }  // container rt-entries
    }  // grouping RT-TABLE

    grouping ORR-GROUP-GLOBAL-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container orr-group-global-table-entries {
        description
          "The BGP Optimal Route Reflection Group Table";
        list orr-group-global-table-entry {
          key "orr-grp-name";
          description
            "A BGP Optimal Route Reflection Group Global
           Table Entry";
          leaf orr-grp-name {
            type xr:Cisco-ios-xr-string;
            description
              "The BGP Optimal Route Reflection Group Name";
          }

          uses BGP-ORR-GROUP-BASE-BAG;
        }  // list orr-group-global-table-entry
      }  // container orr-group-global-table-entries
    }  // grouping ORR-GROUP-GLOBAL-TABLE

    grouping RPKI-ROUTE-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container rpki-routes {
        description "BGP RPKI ROA table";
        list rpki-route {
          description "RPKI Path Group";
          leaf af-name {
            type Bgp-rpki-edm-af;
            description
              "IPv4 or IPV6  Address family";
          }

          leaf address {
            type xr:Cisco-ios-xr-string;
            description
              "IPv4 or IPv6 route prefix contained in the
             Route Origin Authorization";
          }

          leaf minimum {
            type uint32 {
              range "0..128";
            }
            description
              "Length of the shortest prefix allowed";
          }

          leaf maximum {
            type uint32 {
              range "0..128";
            }
            description
              "Length of the longest prefix allowed";
          }

          uses BGP-RPKI-ROUTES-BAG;
        }  // list rpki-route
      }  // container rpki-routes
    }  // grouping RPKI-ROUTE-TABLE

    grouping NEIGHBOR-MISSING-EOR-TABLE {
      description
        "Common node of default-vrf, vrf";
      container neighbor-missing-eor-table {
        description
          "The BGP Neighbor missing eor table";
        uses NEIGHBOR;
      }  // container neighbor-missing-eor-table
    }  // grouping NEIGHBOR-MISSING-EOR-TABLE

    grouping NEIGHBOR-TABLE {
      description
        "Common node of default-vrf, vrf";
      container neighbors {
        description "The BGP Neighbor table";
        uses NEIGHBOR;
      }  // container neighbors
    }  // grouping NEIGHBOR-TABLE

    grouping MESSAGE-LOG-TABLE {
      description
        "Common node of default-vrf, vrf";
      container message-logs {
        description
          "The BGP Neighbor Message table";
        list message-log {
          description
            "A BGP Message log entry";
          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          leaf direction {
            type uint32 {
              range "0..1";
            }
            description
              "Message log Direction";
          }

          uses BGP-MSGLOG-NBR-BAG;
        }  // list message-log
      }  // container message-logs
    }  // grouping MESSAGE-LOG-TABLE

    grouping AF-TABLE {
      description
        "Common node of default-vrf, vrf";
      container afs {
        description
          "BGP address family table";
        list af {
          key "af-name";
          description
            "A particular address family";
          container rpki-refresh-af-table {
            description
              "RPKI Refresh Table (per AF)";
            container rpki-refresh-af {
              description
                "RPKI Refresh List";
              uses BGP-RPKI-REFRESH-LIST-BAG;
            }  // container rpki-refresh-af
          }  // container rpki-refresh-af-table

          container remote-nh-table {
            description
              "A BGP Remote Nexthop table entry";
            uses BGP-RNH-BAG;
          }  // container remote-nh-table

          container policies {
            description
              "The BGP Policy Table";
            list policy {
              description
                "A BGP Policy table entry";
              leaf rd {
                type Bgp-route-distinguisher;
                description
                  "Route Distinguisher value";
              }

              leaf network {
                type xr:Cisco-ios-xr-string;
                description
                  "Network prefix in dotted decimal format for
                 ip prefix, else in hex string format";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Length of the subnet prefix";
              }

              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description
                  "IPv4 or IPv6 Address of the BGP Neighbor";
              }

              uses BGP-PATH-ADV-BAG;
            }  // list policy
          }  // container policies

          container convergence {
            description
              "A BGP Convergence table entry";
            uses BGP-CONVERGENCE-BAG;
          }  // container convergence

          container af-process-info {
            description
              "A BGP Process address family table entry";
            uses BGP-PROCESS-INFO-AF-BAG;
          }  // container af-process-info

          container path-used-table {
            description
              "The BGP Path Used Table";
            uses PATH;
          }  // container path-used-table

          container bmp-path-table-generic {
            description
              "Summary Info about BMP Table";
            uses BGP-BMP-TBL-GBL-BAG;
          }  // container bmp-path-table-generic

          container rpc-sets {
            description
              "BGP next-hop set table";
            list rpc-set {
              key "rpc-set-index";
              description
                "A BGP next-hop set";
              leaf rpc-set-index {
                type uint32;
                description
                  "Nexthop set index";
              }

              uses BGP-RPC-SET-BAG;
            }  // list rpc-set
          }  // container rpc-sets

          container global-af-process-info {
            description
              "The Global Address Family Process information
             table";
            uses BGP-GLOBAL-PROCESS-INFO-AF-BAG;
          }  // container global-af-process-info

          container advertised-path-xr {
            description
              "The BGP Advertised path table (bestpath)";
            list advertised-path {
              description
                "A BGP Advertised path table entry (bestpath)";
              leaf rd {
                type Bgp-route-distinguisher;
                description
                  "Route Distinguisher value";
              }

              leaf network {
                type xr:Cisco-ios-xr-string;
                description
                  "Network prefix in dotted decimal format for
                 ip prefix, else in hex string format";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Length of the subnet prefix";
              }

              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description
                  "IPv4 or IPv6 Address of BGP Neighbor";
              }

              uses BGP-PATH-BAG;
            }  // list advertised-path
          }  // container advertised-path-xr

          container sourced-networks {
            description
              "The BGP Convergence table";
            list sourced-network {
              key "network";
              description
                "A BGP network command table entry";
              leaf network {
                type inet:ip-prefix;
                description
                  "Network in prefix/length format";
              }

              uses BGP-STATIC-ROUTES-BAG;
            }  // list sourced-network
          }  // container sourced-networks

          container update-groups {
            description
              "The BGP Update group table";
            list update-group {
              description
                "A BGP Update group table entry";
              leaf update-group-id {
                type uint32;
                description
                  "A BGP Update group table entry index";
              }

              leaf filter-group-id {
                type uint32;
                description
                  " A BGP Filter group index";
              }

              uses BGP-UPDGRP-BAG;
            }  // list update-group
          }  // container update-groups

          container update-generation-sub-groups {
            description
              "The BGP Update generate entries  for all
             sub-groups";
            list update-generation-sub-group {
              description
                "A BGP Update generate table entry for
               sub-group";
              leaf update-group-index {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "A BGP Update Group Entry index";
              }

              leaf sub-group-index {
                type uint32;
                description
                  "A BGP Update Sub group Table index";
              }

              leaf sub-group-id {
                type uint32;
                description
                  "A BGP Update Sub group table ID";
              }

              uses BGP-UPDGEN-SUBGRP-BAG;
            }  // list update-generation-sub-group
          }  // container update-generation-sub-groups

          container next-hop-address-families {
            description
              "Address family of nexthop table";
            list next-hop-address-family {
              key "next-hop-af-name";
              description
                "Address family of a nexthop entry";
              container next-hop-af-vrf-af {
                description
                  "A BGP Next-hop VRF AF table entry";
                uses BGP-NEXTHOP-VRF-AF-BAG;
              }  // container next-hop-af-vrf-af

              container next-hop-afs {
                description
                  "The BGP Next-hop table";
                list next-hop-af {
                  description
                    "A BGP Next hop entry";
                  leaf next-hop-address {
                    type inet:ip-address-no-zone;
                    description
                      "IP address of Next hop Entry";
                  }

                  leaf attribute-set {
                    type xr:Cisco-ios-xr-string;
                    description
                      "Attribute Set Name";
                  }

                  uses BGP-NEXTHOP-BAG;
                }  // list next-hop-af
              }  // container next-hop-afs

              leaf next-hop-af-name {
                type dt1:Bgp-address-family;
                description "Address family";
              }
            }  // list next-hop-address-family
          }  // container next-hop-address-families

          container rt-set-counters {
            description
              "The RT-set counter table";
            list rt-set-counter {
              key "rt-set-id";
              description
                "One RT-set counter table entry";
              leaf rt-set-id {
                type uint32;
                description
                  "Identifier of RTSet";
              }

              uses BGP-RTSET-BAG;
            }  // list rt-set-counter
          }  // container rt-set-counters

          container bmp-paths {
            description
              "The paths in BMP Table";
            list bmp-path {
              key "network";
              description
                "A BMP path table entry";
              leaf network {
                type inet:ip-prefix;
                description
                  "Network in prefix/length format";
              }

              uses BGP-BMP-NET-BAG;
            }  // list bmp-path
          }  // container bmp-paths

          container update-generation-update-groups {
            description
              "The BGP Update generate entries for all
             update-groups";
            list update-generation-update-group {
              key "update-group-index";
              description
                "A BGP Update Generate Group Entry";
              leaf update-group-index {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "Update group index of the update-group table";
              }

              uses BGP-UPDGEN-UPDGRP-BAG;
            }  // list update-generation-update-group
          }  // container update-generation-update-groups

          container update-generation-filter-groups {
            description
              "Update generation for all filter-groups under
             a sub-group";
            list update-generation-filter-group {
              description
                "A BGP Update generate table entry for
               filter-group";
              leaf update-group-index {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "A BGP Update Group Entry index";
              }

              leaf sub-group-index {
                type uint32;
                description
                  "A BGP Update Sub group Table index";
              }

              leaf sub-group-id {
                type uint32;
                description
                  "A BGP Update Sub group table ID";
              }

              leaf filter-group-index {
                type uint32;
                description
                  "A BGP Filter group Table index";
              }

              uses BGP-UPDGEN-FILTERGRP-BAG;
            }  // list update-generation-filter-group
          }  // container update-generation-filter-groups

          container networks {
            description
              "The BGP Network Table";
            list network {
              description
                "A BGP Network table entry";
              leaf rd {
                type Bgp-route-distinguisher;
                description
                  "Route Distinguisher value";
              }

              leaf network {
                type xr:Cisco-ios-xr-string;
                description
                  "Network prefix in dotted decimal format for
                 ip prefix, else in hex string format";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Length of the subnet prefix";
              }

              uses BGP-NET-BAG;
            }  // list network
          }  // container networks

          container path-table {
            description "The BGP Path Table";
            uses PATH;
          }  // container path-table

          container mvpn-rt-list {
            description
              "A BGP Multicast VPN Route Target List for
             address-family";
            uses BGP-MVPN-RT-LIST-BAG;
          }  // container mvpn-rt-list

          container recent-prefixes {
            description
              "BGP Recent Prefix Table";
            list recent-prefix {
              description
                "BGP Recent Prefix";
              leaf rd {
                type Bgp-route-distinguisher;
                description
                  "Route Distinguisher value";
              }

              leaf network {
                type xr:Cisco-ios-xr-string;
                description
                  "Network prefix in dotted decimal format for
                 ip prefix, else in hex string format";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Length of the subnet prefix";
              }

              uses BGP-RECENT-NET-BAG;
            }  // list recent-prefix
          }  // container recent-prefixes

          container advertised-path-counts {
            description
              "The BGP Advertised paths table (bestpath)";
            list advertised-path-count {
              key "neighbor-address";
              description
                "The BGP Advertised path table Count
               (bestpath)";
              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description
                  "IPv4 or IPv6 Address of the BGP Neighbor";
              }

              uses BGP-NBR-ADV-CNT-BAG;
            }  // list advertised-path-count
          }  // container advertised-path-counts

          container path-labeled-table {
            description
              "The BGP Path Labeled Table";
            uses PATH;
          }  // container path-labeled-table

          container orr-group-table-entries {
            description
              "The BGP Optimal Route Reflection Group Table";
            list orr-group-table-entry {
              key "orr-grp-name";
              description
                "A BGP Optimal Route Reflection Group Table
               Entry";
              leaf orr-grp-name {
                type xr:Cisco-ios-xr-string;
                description
                  "The BGP Optimal Route Reflection Group Name";
              }

              uses BGP-ORR-GROUP-BAG;
            }  // list orr-group-table-entry
          }  // container orr-group-table-entries

          container advertised-paths {
            description
              "The BGP Advertised paths table (add-paths)";
            list advertised-path {
              description
                "A BGP Advertised paths table entry
               (add-paths)";
              leaf rd {
                type Bgp-route-distinguisher;
                description
                  "Route Distinguisher value";
              }

              leaf network {
                type xr:Cisco-ios-xr-string;
                description
                  "Network prefix in dotted decimal format for
                 ip prefix, else in hex string format";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Length of the subnet prefix";
              }

              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description "Neighbor ";
              }

              uses BGP-PATH-MULTI;
            }  // list advertised-path
          }  // container advertised-paths

          container neighbor-af-table {
            description
              "The BGP Neighbor AF table";
            uses NEIGHBOR;
          }  // container neighbor-af-table

          container epe-objects {
            description
              "The BGP Egress Engineering table";
            list epe-object {
              description
                "A BGP Egress Engineering object";
              leaf epe-type {
                type Bgp-epe-obj;
                description
                  "Type of EPE object. Can be Peer, Peer-set or
                 Adjacency";
              }

              leaf epe-object-key {
                type xr:Cisco-ios-xr-string;
                description
                  "Value of the EPE object.Please provide a
                 number forPeer-Set and an IP addressfor peer
                 or adjacency";
              }

              uses BGP-EPE-SET-BAG;
            }  // list epe-object
          }  // container epe-objects

          container update-generation-neighbors {
            description
              "A BGP Update generate Table Entry for all BGP
             neighbors";
            list update-generation-neighbor {
              description
                "BGP Update generate entry for BGP neighbor";
              leaf update-group-index {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "A BGP Update Group Entry index";
              }

              leaf sub-group-index {
                type uint32;
                description
                  "A BGP Update Sub group Table index";
              }

              leaf sub-group-id {
                type uint32;
                description
                  "A BGP Update Sub group table ID";
              }

              leaf filter-group-index {
                type uint32;
                description
                  "A BGP Filter group Table index";
              }

              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description
                  "IPv4 or IPv6 Address of the BGP Neighbor";
              }

              uses BGP-UPDGEN-NBR-BAG;
            }  // list update-generation-neighbor
          }  // container update-generation-neighbors

          container update-generation-address-family {
            description
              "A BGP Update Generate Entry for address-family";
            uses BGP-UPDGEN-AF-BAG;
          }  // container update-generation-address-family

          container dampenings {
            description
              "The BGP Dampening table";
            list dampening {
              description
                "A BGP Dampening table entry";
              leaf reuse {
                type uint32 {
                  range "0..65535";
                }
                description
                  "Reuse array index";
              }

              leaf version {
                type uint32 {
                  range "0..4294967295";
                }
                description "Version number";
              }

              leaf rd {
                type Bgp-route-distinguisher;
                description
                  "Route Distinguisher value";
              }

              leaf network {
                type xr:Cisco-ios-xr-string;
                description
                  "Network prefix in dotted decimal format for
                 ip prefix, else in hex string format";
              }

              leaf length {
                type uint32 {
                  range "0..128";
                }
                description
                  "Length of the subnet prefix";
              }

              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description
                  "IPv4 or IPv6 Address of the BGP Neighbor";
              }

              leaf source-rd {
                type Bgp-route-distinguisher;
                description
                  "Source Route Distinguisher value";
              }

              leaf orig-source-rd {
                type Bgp-route-distinguisher;
                description
                  "Original Source Route Distinguisher value";
              }

              leaf path-id {
                type uint32 {
                  range "0..4294967295";
                }
                description
                  "Received Path ID";
              }

              uses BGP-PATH-BAG;
            }  // list dampening
          }  // container dampenings

          container dependency {
            description
              "A BGP Dependency table entry";
            uses BGP-DEP-BAG;
          }  // container dependency

          container prefix-filters {
            description
              "The BGP Prefix Filter table";
            list prefix-filter {
              key "neighbor-address";
              description
                "A BGP prefix filter table entry";
              leaf neighbor-address {
                type inet:ip-address-no-zone;
                description
                  "IPv4 or IPv6 Address of the BGP Neighbor";
              }

              uses BGP-RCV-PFXLST-BAG;
            }  // list prefix-filter
          }  // container prefix-filters

          leaf af-name {
            type dt1:Bgp-address-family;
            description "Address family";
          }

          uses ATTRIBUTE-TABLE;
        }  // list af
      }  // container afs
    }  // grouping AF-TABLE

    grouping PROCESS-INFO {
      description
        "Common node of default-vrf, vrfCommon node of
       default-vrf, vrf";
      container process-info {
        description
          "A Process instance table entry";
        uses BGP-PROCESS-INFO-BAG;
      }  // container process-info
    }  // grouping PROCESS-INFO

    grouping OBJECT-TRACKING-PROVIDER-NBR-AF-TABLE {
      description
        "Common node of instance-active, instance-standby";
      container ot-prov-nbr-af-entries {
        description
          "BGP Object Tracking Provider Neighbor AF Table";
        list ot-prov-nbr-af-entry {
          description
            "BGP Object Tracking Provider Nbr Af Database
           Entry";
          leaf vrf-name {
            type xr:Cisco-ios-xr-string;
            description "Name of the VRF";
          }

          leaf af-name {
            type dt1:Bgp-address-family;
            description "Address family";
          }

          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          uses BGP-OT-PROV-NBR-AF-DB-BAG;
        }  // list ot-prov-nbr-af-entry
      }  // container ot-prov-nbr-af-entries
    }  // grouping OBJECT-TRACKING-PROVIDER-NBR-AF-TABLE

    grouping CONFIGURATION-INHERITANCE-TABLE {
      description
        "Common node of config-instance-default-vrf,
       config-vrf";
      container configuration-inheritances {
        description
          "The BGP configuration inheritance table";
        list configuration-inheritance {
          description
            "A BGP configuration inheritance table entry";
          leaf entity-type {
            type Bgp-entity;
            description
              "Type of the entity configuration inheritance
             table entry";
          }

          leaf neighbor-address {
            type inet:ip-address-no-zone;
            description
              "IPv4 or IPv6 Address of the BGP Neighbor";
          }

          leaf entity-name {
            type xr:Cisco-ios-xr-string;
            description
              "Name of the entity configuration inheritance
             table entry";
          }

          leaf length {
            type uint32 {
              range "0..128";
            }
            description
              "Length of the subnet prefix";
          }

          uses BGP-CONFIG-RELATIVES-BAG;
        }  // list configuration-inheritance
      }  // container configuration-inheritances
    }  // grouping CONFIGURATION-INHERITANCE-TABLE

    grouping UPDATE-INBOUND-FILTER-PROCESS {
      description
        "Common node of instance-active, instance-standby";
      container update-inbound-filter-process {
        description
          "Update inbound filtering information for the
         process";
        uses BGP-UPDFILTER-PROC-BAG;
      }  // container update-inbound-filter-process
    }  // grouping UPDATE-INBOUND-FILTER-PROCESS

    container bgp {
      config false;
      description "BGP operational data";
      container config-instances {
        description
          "Instance specific BGP data";
        list config-instance {
          key "instance-name";
          description
            "Instance specific BGP data";
          container config-instance-default-vrf {
            description
              "Default VRF related configuration data";
            uses ENTITY-CONFIGURATION-TABLE;

            uses CONFIGURATION-USER-TABLE;

            uses CONFIGURATION-INHERITANCE-TABLE;
          }  // container config-instance-default-vrf

          container config-vrfs {
            description
              "VRF related configuration data";
            list config-vrf {
              key "vrf-name";
              description
                "Configuration data for a particular VRF";
              leaf vrf-name {
                type xr:Cisco-ios-xr-string;
                description
                  "Name of the VRF";
              }

              uses ENTITY-CONFIGURATION-TABLE;

              uses CONFIGURATION-USER-TABLE;

              uses CONFIGURATION-INHERITANCE-TABLE;
            }  // list config-vrf
          }  // container config-vrfs

          leaf instance-name {
            type xr:Cisco-ios-xr-string;
            description
              "Name of the BGP instance";
          }
        }  // list config-instance
      }  // container config-instances

      container instances {
        description
          "Instance specific BGP data";
        list instance {
          key "instance-name";
          description
            "Instance specific BGP data";
          container instance-active {
            description
              "Active BGP operational data";
            container segment-routing {
              description
                "Segment Routing related Operational Data";
              container srv6 {
                description
                  "SRv6 related Operational Data";
                container summary {
                  description
                    "BGP SRv6 Summary";
                  uses BGP-SRV6-SUMMARY-BAG;
                }  // container summary

                container locator-entries {
                  description
                    "BGP SRv6 Locator Table";
                  list locator-entry {
                    key "locator-name";
                    description
                      "BGP SRv6 Locator Table Entry";
                    leaf locator-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "Locator Name";
                    }

                    uses BGP-SRV6-LOCATOR-BAG;
                  }  // list locator-entry
                }  // container locator-entries

                container sid-manager {
                  description
                    "BGP SRv6 SID Manager";
                  uses BGP-SRV6-SID-MANAGER-BAG;
                }  // container sid-manager
              }  // container srv6
            }  // container segment-routing

            container label-entries {
              description "BGP Label Table";
              list label-entry {
                key "label";
                description
                  "BGP Label Entry";
                leaf label {
                  type uint32 {
                    range "0..1048575";
                  }
                  description "Label index";
                }

                uses BGP-LABEL-BAG;
              }  // list label-entry
            }  // container label-entries

            container label-summary {
              description
                "BGP Label Summary";
              uses BGP-LABEL-SUMMARY-BAG;
            }  // container label-summary

            container graceful-maintenance {
              description
                "BGP graceful maintenance related Operational
               Data";
              container all-neighbor-entries {
                description
                  "BGP graceful-maintenance  nbr-all Table";
                list all-neighbor-entry {
                  key "nbr-all";
                  description
                    "BGP graceful-maintenance nbr-all Table
                   Entry";
                  leaf nbr-all {
                    type uint32;
                    description
                      "All neighbor state";
                  }

                  uses BGP-GSHUT-NBR-ALL-BAG;
                }  // list all-neighbor-entry
              }  // container all-neighbor-entries

              container location-entries {
                description
                  "BGP graceful-maintenance Location Table";
                list location-entry {
                  key "node-id";
                  description
                    "BGP graceful-maintenance Location Table
                   Entry";
                  leaf node-id {
                    type xr:Node-id;
                    description
                      "NodeID of the Location";
                  }

                  uses BGP-GSHUT-LOC-BAG;
                }  // list location-entry
              }  // container location-entries

              container interface-entries {
                description
                  "BGP graceful-maintenance Interface Table";
                list interface-entry {
                  key "interface-name";
                  description
                    "BGP graceful-maintenance Interface Table
                   Entry";
                  leaf interface-name {
                    type xr:Interface-name;
                    description
                      "Interface Name";
                  }

                  uses BGP-GSHUT-IF-BAG;
                }  // list interface-entry
              }  // container interface-entries
            }  // container graceful-maintenance

            container label-rpf-entries {
              description
                "BGP Label RPF Table";
              list label-rpf-entry {
                key "label";
                description
                  "BGP Label RPF Entry";
                leaf label {
                  type uint32 {
                    range "0..1048575";
                  }
                  description "Label index";
                }

                uses BGP-LABEL-RPF-BAG;
              }  // list label-rpf-entry
            }  // container label-rpf-entries

            uses UPDATE-GENERATION-PROCESS;

            uses VRF-TABLE;

            uses DEFAULT-VRF;

            uses UPDATE-INBOUND-FILTER-PROCESS;

            uses VRFDBVR-FENTRY;

            uses ATTRIBUTE-TABLE;

            uses RT-TABLE;

            uses ATTRIBUTE-FILTER-GROUP-TABLE;

            uses ORR-GROUP-GLOBAL-TABLE;

            uses VRFDBVRF-TABLE;

            uses RPKI-SERVER-LIST;

            uses RPKI-ROUTE-TABLE;

            uses UPDATE-INBOUND-ERROR-PROCESS;

            uses RPKI-SUMMARY;

            uses RT-HASH-TABLE;

            uses OBJECT-TRACKING-PROVIDER-NBR-AF-TABLE;
          }  // container instance-active

          container instance-standby {
            description
              "Standby BGP operational data";
            uses UPDATE-GENERATION-PROCESS;

            uses VRF-TABLE;

            uses DEFAULT-VRF;

            uses UPDATE-INBOUND-FILTER-PROCESS;

            uses VRFDBVR-FENTRY;

            uses ATTRIBUTE-TABLE;

            uses RT-TABLE;

            uses ATTRIBUTE-FILTER-GROUP-TABLE;

            uses ORR-GROUP-GLOBAL-TABLE;

            uses VRFDBVRF-TABLE;

            uses RPKI-SERVER-LIST;

            uses RPKI-ROUTE-TABLE;

            uses UPDATE-INBOUND-ERROR-PROCESS;

            uses RPKI-SUMMARY;

            uses RT-HASH-TABLE;

            uses OBJECT-TRACKING-PROVIDER-NBR-AF-TABLE;
          }  // container instance-standby

          leaf instance-name {
            type xr:Cisco-ios-xr-string;
            description
              "Name of the BGP instance";
          }
        }  // list instance
      }  // container instances

      container bpm-instances-table {
        description
          "BGP instances information";
        container bpm-instances {
          description
            "BGP instances information";
          uses BGP-INSTANCES-INFO-BAG;
        }  // container bpm-instances

        container bpm-orr-group-table-entries {
          description
            "Optimal Route Reflection Group Table in BPM";
          list bpm-orr-group-table-entry {
            key "orr-grp-name";
            description
              "Optimal Route Reflection Group Table Entry in
             BPM";
            leaf orr-grp-name {
              type xr:Cisco-ios-xr-string;
              description
                "The BGP Optimal Route Reflection Group Name";
            }

            uses BPM-ORR-GROUP-BAG;
          }  // list bpm-orr-group-table-entry
        }  // container bpm-orr-group-table-entries
      }  // container bpm-instances-table
    }  // container bgp
  }  // module Cisco-IOS-XR-ipv4-bgp-oper