Cisco-IOS-XR-ipv4-bgp-cfg.yang

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

  /*** NAMESPACE / PREFIX DEFINITION ***/

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


  prefix "ipv4-bgp-cfg";

  /*** LINKAGE (IMPORTS / INCLUDES) ***/

  import ietf-inet-types { prefix "inet"; }

  import Cisco-IOS-XR-types { prefix "xr"; }

  import Cisco-IOS-XR-ipv4-bgp-datatypes { prefix "dt1"; }

  import Cisco-IOS-XR-infra-rsi-cfg { prefix "a1"; }

  import Cisco-IOS-XR-snmp-agent-cfg { prefix "a2"; }

  /*** META INFORMATION ***/

  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 configuration.

     This module contains definitions
     for the following management objects:
       bgp: BGP configuration commands
       bmp-server-all: bmp server all
       bmp-servers: bmp servers

     This YANG module augments the
       Cisco-IOS-XR-infra-rsi-cfg,
       Cisco-IOS-XR-snmp-agent-cfg
     modules with configuration data.

     Copyright (c) 2013-2016 by Cisco Systems, Inc.
     All rights reserved.";

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

  typedef Bgp-mvpn-sfs-select {
    type enumeration {
      enum all-paths {
        value 1;
        description "Select all paths as single forwarder PE";
      }
      enum highest-ip-address {
        value 2;
        description
          "Select PE with highest address as single
          forwarder PE";
      }
    }
    description "Bgp mvpn sfs select";
  }
  typedef Bmp-policy-select {
    type enumeration {
      enum post-policy {
        value 2;
        description "Pickup routes after policy application";
      }
    }
    description "Bmp policy select";
  }
  typedef Bgp-default-metric-range {
    type uint32 {
      range "0..4294967295";
    }
    description "Bgp default metric range";
  }
  typedef Bgp-ebgp-send-dmz-enable-mode {
    type enumeration {
      enum disable {
        value 0;
        description "Disable Mode - Prevent inheritance";
      }
      enum default {
        value 1;
        description
          "Default Mode - Send dmz link bandwidth value to
          ebgp neighbor";
      }
      enum cumulative {
        value 2;
        description
          "Strict Mode - Send cumulative dmz link
          bandwidth value to ebgp neighbor";
      }
    }
    description "Bgp ebgp send dmz enable mode";
  }
  typedef Bgp-signal {
    type enumeration {
      enum bgp-disable {
        value 1;
        description "Signalling BGP disable";
      }
      enum ldp-disable {
        value 2;
        description "Signalling LDP disable";
      }
    }
    description "Bgp signal";
  }
  typedef Bgp-vrf-route-target {
    type enumeration {
      enum as {
        value 0;
        description "AS format RT";
      }
      enum ipv4-address {
        value 1;
        description "IPv4 address format RT";
      }
      enum four-byte-as {
        value 2;
        description "4-byte AS format RT";
      }
    }
    description "Bgp vrf route target";
  }
  typedef Bgp-rnh-install-format {
    type enumeration {
      enum ext-comm {
        value 0;
        description "Install RNH as opaque and extcomm";
      }
      enum ext-comm-only {
        value 1;
        description "Install RNH as extcomm only";
      }
    }
    description "Bgp rnh install format";
  }
  typedef Bgp-bfd-enable-mode {
    type enumeration {
      enum disable {
        value 0;
        description "Disable Mode - Prevent inheritance";
      }
      enum default {
        value 1;
        description "Default Mode - Default BFD behavior";
      }
      enum strict {
        value 2;
        description
          "Strict Mode - Hold down adj until BFD session
          up";
      }
    }
    description "Bgp bfd enable mode";
  }
  typedef Route-target-as-index {
    type uint32 {
      range "0..4294967295";
    }
    description "Route target as index";
  }
  typedef Bmp-route-direction {
    type enumeration {
      enum inbound {
        value 1;
        description "Pickup routes at inbound direction from peer";
      }
    }
    description "Bmp route direction";
  }
  typedef Bgp-send-mcast-attr-cfg {
    type enumeration {
      enum enable {
        value 1;
        description "Enable SendMcastAttr";
      }
      enum disable {
        value 2;
        description "Disable SendMcastAttr";
      }
    }
    description "Bgp send mcast attr cfg";
  }
  typedef Bgp-aigp-cfg-poi {
    type enumeration {
      enum pre-best-path {
        value 1;
        description "AIGP Pre-bestpath POI";
      }
      enum igp-cost {
        value 2;
        description "AIGP igp-cost POI";
      }
    }
    description "Bgp aigp cfg poi";
  }
  typedef Bgp-flowspec-validation-cfg {
    type enumeration {
      enum enable {
        value 1;
        description "Enable Flowspec validation";
      }
      enum disable {
        value 2;
        description "Disable Flowspec validation";
      }
      enum redirect-nexhop-disable {
        value 3;
        description "Disable Flowspec redirect nexthop validation";
      }
    }
    description "Bgp flowspec validation cfg";
  }
  typedef Route-target-addr-index {
    type uint32 {
      range "0..65535";
    }
    description "Route target addr index";
  }
  typedef Bgp-orf {
    type enumeration {
      enum none {
        value 0;
        description "No capability to send or receive";
      }
      enum receive {
        value 1;
        description "Receive ORF capability";
      }
      enum send {
        value 2;
        description "Send ORF capability";
      }
      enum both {
        value 3;
        description "Send and receive ORF capability";
      }
    }
    description "Bgp orf";
  }
  typedef Bgp-rpki-transport {
    type enumeration {
      enum tcp {
        value 0;
        description "TCP Transport";
      }
      enum ssh {
        value 1;
        description "SSH Transport";
      }
    }
    description "Bgp rpki transport";
  }
  typedef Bgp-reorg-opt {
    type enumeration {
      enum bgp-cfg-adv {
        value 1;
        description "Advertise translated routes";
      }
      enum bgp-cfg-adv-reorg {
        value 2;
        description "Advertise Reorig routes";
      }
      enum bgp-cfg-adv-disable {
        value 3;
        description "Disable adv of routes";
      }
      enum bgp-cfg-adv-local {
        value 4;
        description "Advertise local routes";
      }
      enum bgp-cfg-adv-def-vrf-imp-disable {
        value 5;
        description "Disable adv of Def VRF Imported routes";
      }
      enum bgp-cfg-adv-vrf-re-imp-disable {
        value 6;
        description "Disable adv of VRF ReImported routes";
      }
    }
    description "Bgp reorg opt";
  }
  typedef Bgp-af-encapsulation {
    type enumeration {
      enum vx-lan {
        value 1;
        description "VxLAN encapsulation type";
      }
    }
    description "Bgp af encapsulation";
  }
  typedef Bgp-aigp-cfg {
    type enumeration {
      enum enable {
        value 1;
        description "Enable AIGP";
      }
      enum disable {
        value 2;
        description "Disable AIGP";
      }
    }
    description "Bgp aigp cfg";
  }
  typedef Bgp-route-distinguisher {
    type enumeration {
      enum auto {
        value 1;
        description "Automatically assigned";
      }
      enum as {
        value 2;
        description "AS format RD";
      }
      enum four-byte-as {
        value 3;
        description "4-byte AS format RD";
      }
      enum ipv4-address {
        value 4;
        description "IPv4 address format RD";
      }
    }
    description "Bgp route distinguisher";
  }
  typedef Bgp-adv-rt {
    type enumeration {
      enum bgp-regular-rt {
        value 0;
        description "Regular RT type";
      }
      enum bgp-stitching-rt {
        value 1;
        description "Stitching RT type";
      }
    }
    description "Bgp adv rt";
  }
  typedef Bgp-tcp-mode {
    type enumeration {
      enum either {
        value 0;
        description "Either active or passive mode";
      }
      enum active-only {
        value 1;
        description "Active mode only";
      }
      enum passive-only {
        value 2;
        description "Passive mode only";
      }
    }
    description "Bgp tcp mode";
  }
  typedef Bgp-site-of-origin {
    type enumeration {
      enum as {
        value 0;
        description "AS format SoO";
      }
      enum ipv4-address {
        value 1;
        description "IPv4 address format SoO";
      }
      enum four-byte-as {
        value 2;
        description "4-byte AS format SoO";
      }
    }
    description "Bgp site of origin";
  }
  typedef Bgp-cluster-id {
    type enumeration {
      enum number {
        value 1;
        description "Number";
      }
      enum ipv4-address {
        value 2;
        description "IPv4 Address";
      }
    }
    description "Bgp cluster id";
  }

  grouping ADVERTISE-DISABLE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-disable {
      description "Disable Advertise Of Routes to the peer";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping TABLE-POLICY {
    description "Common node of global-af, vrf-global-af";
    leaf table-policy {
      type string;
      description
        "Configure policy for installation of routes to
        RIB";
    }
  }

  grouping MAXIMUM-PREFIXES {
    description
      "Common node of global-af, vrf-global-afCommon
      node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container maximum-prefixes {
      presence "Indicates a maximum-prefixes node is configured.";
      description
        "Maximum number of prefixes to accept from this
        peer";
      leaf prefix-limit {
        type uint32 {
          range "1..4294967295";
        }
        mandatory true;
        description "Maximum prefixes limit";
      }
      leaf warning-percentage {
        type uint32 {
          range "1..100";
        }
        default "75";
        description
          "Threshold value (%) at which to generate a
          warning message.";
      }
      leaf warning-only {
        type boolean;
        default "false";
        description
          "TRUE to only give a warning message when limit
          is exceeded.  FALSE to accept max prefix limit
          only.";
      }
      leaf restart-time {
        type uint32 {
          range "0..65535";
        }
        default "0";
        description "Restart interval";
      }
      leaf discard-extra-paths {
        type boolean;
        default "false";
        description "Discard extra paths when limit is exceeded";
      }
    }
  }

  grouping DISTANCE {
    description "Common node of global-af, vrf-global-af";

    container distance {
      description "Define an administrative distance";
      leaf external-routes {
        type uint32 {
          range "1..255";
        }
        default "20";
        description "Distance for routes external to the AS";
      }
      leaf internal-routes {
        type uint32 {
          range "1..255";
        }
        default "200";
        description "Distance for routes internal to the AS";
      }
      leaf local-routes {
        type uint32 {
          range "1..255";
        }
        default "200";
        description "Distance for local routes";
      }
    }
  }

  grouping UPDATE-SOURCE-INTERFACE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf update-source-interface {
      type xr:Interface-name;
      description "Select an interface to configure";
    }
  }

  grouping MULTI-PATH-AS-PATH-IGNORE-ONWARDS {
    description "Common node of global, vrf-global";
    leaf multi-path-as-path-ignore-onwards {
      type empty;
      description
        "Change default multi-route selection criteria to
        ignore everything onwards as-path check";
    }
  }

  grouping PROPAGATE-DMZ-LINK-BANDWIDTH {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf propagate-dmz-link-bandwidth {
      type boolean;
      description
        "TRUE to propagate DMZ link bandwidth.  FALSE to
        not propagate and to prevent inheritance from a
        parent";
    }
  }

  grouping DISABLE-AUTO-SOFT-RESET {
    description "Common node of global, vrf-global";
    leaf disable-auto-soft-reset {
      type empty;
      description
        "Disable automatic soft peer reset on policy
        reconfiguration";
    }
  }

  grouping MSG-LOG-IN {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container msg-log-in {
      description "Message log inbound";
      leaf msg-buf-count {
        type uint32 {
          range "1..100";
        }
        description "Inbound message log buffer size";
      }
      leaf msg-log-disable {
        type boolean;
        description "Disable inbound message logging";
      }
      leaf msg-log-inherit-disable {
        type boolean;
        description
          "TRUE, to prevent this entity from having a
          inbound message logging if parent has one";
      }
    }
  }

  grouping DISABLE-ENFORCE-FIRST-AS {
    description "Common node of global, vrf-global";
    leaf disable-enforce-first-as {
      type empty;
      description "Disable enforce the first AS for EBGP routes";
    }
  }

  grouping ROUTE-TARGET-TABLE {
    description
      "Common node of import-route-targets,
      export-route-targets";

    container route-targets {
      description "Route target table";

      list route-target {
        must "as-or-four-byte-as or ipv4-address" {
          description
            "AS-or-FourByteAS or IPV4Address must be
            present.";
        }
        key "type";
        description "Route target";
        leaf type {
          type Bgp-vrf-route-target;
          description "Type of RT";
        }

        list as-or-four-byte-as {
          when "../type = 'as' or ../type = 'four-byte-as'" {
            description "../Type = AS or ../Type = FourByteAS";
          }
          key "as-xx as as-index stitching-rt";
          description "as or four byte as";
          leaf as-xx {
            type uint32;
            description "AS number";
          }
          leaf as {
            type uint32 {
              range "1..4294967295";
            }
            description "AS number";
          }
          leaf as-index {
            type Route-target-as-index;
            description "AS number Index";
          }
          leaf stitching-rt {
            type uint32 {
              range "0..1";
            }
            description "Stitching RT";
          }
        }

        list ipv4-address {
          when "../type = 'ipv4-address'" {
            description "../Type = IPV4Address";
          }
          key "address address-index stitching-rt";
          description "ipv4 address";
          leaf address {
            type inet:ipv4-address-no-zone;
            description "IP address";
          }
          leaf address-index {
            type Route-target-addr-index;
            description "IP address Index";
          }
          leaf stitching-rt {
            type uint32 {
              range "0..1";
            }
            description "Stitching RT";
          }
        }
      }
    }
  }

  grouping REMOTE-AS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container remote-as {
      description "Set remote AS";
      leaf as-xx {
        type dt1:Bgp-as-range;
        description "xx of AS number xx.yy";
      }
      leaf as-yy {
        type dt1:Bgp-as-range;
        description "yy of AS number xx.yy";
      }
    }
  }

  grouping ADDITIONAL-PATHS-SEND {
    description "Common node of global-af, vrf-global-af";
    leaf additional-paths-send {
      type dt1:Bgpaf-additional-paths-cfg;
      description "Advertise additional paths Send capability";
    }
  }

  grouping UPDATE-IN-FILTERING {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container update-in-filtering {
      description "Inbound update filtering";

      container update-in-filtering-message-buffers {
        presence "Indicates a update-in-filtering-message-buffers"+
          " node is configured.";
        description "Message buffers to store filtered updates";
        leaf number-of-buffers {
          type uint32 {
            range "0..25";
          }
          mandatory true;
          description "Number of message buffers";
        }
        leaf non-circular-buffer {
          type boolean;
          mandatory true;
          description "TRUE to configure non-circular buffer";
        }
      }
      leaf enable {
        type empty;
        description "Configure inbound update filtering";
      }
      leaf update-in-filtering-attribute-filter-group {
        type string;
        description
          "Attribute-filter group name for update
          filtering";
      }
      leaf update-in-filtering-syslog-disable {
        type empty;
        description
          "Disable inbound update filtering syslog
          messages";
      }
    }
  }

  grouping SHUTDOWN {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf shutdown {
      type boolean;
      description
        "TRUE to shutdown this entity, FALSE to prevent
        this entity from being shutdown even if the
        parent is.";
    }
  }

  grouping BMP-ACTIVATE-TABLE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container bmp-activates {
      description "Enable BMP logging for this neighbor";

      list bmp-activate {
        key "server-id";
        description "Enable BMP logging for this particular server";
        leaf server-id {
          type uint32 {
            range "1..8";
          }
          description "BMP Server ID";
        }
      }
    }
  }

  grouping ADVERTISE-VRF-IMP-DISABLE-V4 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-vrf-imp-disable-v4 {
      description "Disable Advertise Of VRF ReImported Routes";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf adv-option {
        type Bgp-reorg-opt;
        description "Advertise option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping ADVERTISE-VRF-IMP-DISABLE-V6 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-vrf-imp-disable-v6 {
      description "Disable Advertise Of VRF ReImported Routes";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf adv-option {
        type Bgp-reorg-opt;
        description "Advertise option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping SITE-OF-ORIGIN {
    description
      "Common node of neighbor-group-af, vrf-neighbor-af
      , af-group-af";

    container site-of-origin {
      description
        "Site-of-Origin extended community associated
        with the neighbor";
      leaf type {
        type Bgp-site-of-origin;
        description "Type of Extended community";
      }
      leaf as-xx {
        when "../type = 'as' or ../type = 'four-byte-as'" {
          description "../Type = AS or ../Type = FourByteAS";
        }
        type dt1:Bgp-as-range;
        description "AS number";
      }
      leaf as {
        when "../type = 'as' or ../type = 'four-byte-as'" {
          description "../Type = AS or ../Type = FourByteAS";
        }
        type dt1:Bgp-as-range;
        description "AS number";
      }
      leaf as-index {
        when "../type = 'as' or ../type = 'four-byte-as'" {
          description "../Type = AS or ../Type = FourByteAS";
        }
        type dt1:Bgp-extcomm-asn-index;
        description "AS number Index";
      }
      leaf address {
        when "../type = 'ipv4-address'" {
          description "../Type = IPV4Address";
        }
        type inet:ipv4-address-no-zone;
        description "IP address";
      }
      leaf address-index {
        when "../type = 'ipv4-address'" {
          description "../Type = IPV4Address";
        }
        type dt1:Bgp-extcomm-v4-addr-index;
        description "IP address Index";
      }
    }
  }

  grouping ROUTE-POLICY-OUT {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf route-policy-out {
      type string;
      description "Route policy name to apply to outbound routes";
    }
  }

  grouping ADVERTISE-V4 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-v4 {
      description "Advertise Translated Routes to the peer";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping ADVERTISE-V6 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-v6 {
      description "Advertise Translated Routes to the peer";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping DEFAULT-ORIGINATE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container default-originate {
      description "Originate default route to this neighbor";
      leaf enable {
        type boolean;
        default "false";
        description
          "FALSE to prevent default-originate from, being
          inherited from a parent. TRUE otherwise.";
      }
      leaf route-policy-name {
        type string;
        description
          "Route policy name to specify criteria to
          originate default.";
      }
    }
  }

  grouping IDLE-WATCH-TIME {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf idle-watch-time {
      type uint32 {
        range "30..1800";
      }
      units "second";
      description
        "Time to wait for deleteing IDLE state Dynamic
        peer";
    }
  }

  grouping TIMERS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container timers {
      description "BGP per neighbor timers.";
      leaf keepalive-interval {
        type uint32 {
          range "0..65535";
        }
        default "60";
        description "Keepalive interval";
      }
      leaf hold-time {
        type uint32 {
          range "0..65535";
        }
        default "180";
        description
          "Hold time.  Specify 0 to disable
          keepalives/hold time";
      }
      leaf min-accept-hold-time {
        type uint32 {
          range "0..65535";
        }
        default "3";
        description
          "Minimum acceptable hold time.  Specify 0 to
          disable keepalives/hold time";
      }
    }
  }

  grouping DISABLE-FAST-EXTERNAL-FALLOVER {
    description "Common node of global, vrf-global";
    leaf disable-fast-external-fallover {
      type empty;
      description
        "Disable immediate reset session if a link to a
        directly connected external peer goes down";
    }
  }

  grouping SEND-COMMUNITY-EBGP {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf send-community-ebgp {
      type boolean;
      description
        "TRUE to send communities to the external
        neighbor/neighbor-group/af-group.  FALSE not to
        send and to prevent inheritance from a parent";
    }
  }

  grouping ADDITIONAL-PATHS-RECEIVE-CAPABILITY {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf additional-paths-receive-capability {
      type dt1:Bgp-nbr-cap-additional-paths-cfg;
      description "Advertise additional paths Receive capability";
    }
  }

  grouping SEND-EXT-COMMUNITY-EBGP {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf send-ext-community-ebgp {
      type boolean;
      description
        "TRUE to send extended communities to the
        external neighbor/neighbor-group/af-group. 
        FALSE not to send and to prevent inheritance
        from a parent";
    }
  }

  grouping AF-GROUP {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af";
    leaf af-group {
      type string;
      description
        "Inherit configuration for this address-family
        from an AF-group";
    }
  }

  grouping ROUTE-POLICY-IN {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf route-policy-in {
      type string;
      description "Route policy name to apply to inbound routes";
    }
  }

  grouping LABEL-MODE {
    description "Common node of global-af, vrf-global-af";

    container label-mode {
      description "BGP 6PE/MPLS-VPN label allocation mode";
      leaf label-allocation-mode {
        type string;
        description
          "Label allocation mode: per-ce  Set per CE label
          mode, per-vrf Set per VRF label mode,
          per-prefix Set per Prefix label mode (for
          MPLS-VPN only)";
      }
      leaf route-policy-name {
        type string;
        description "Label mode route policy name";
      }
    }
  }

  grouping APP-ROUTE-TABLE {
    description "Common node of global-af, vrf-global-af";

    container application-routes {
      description
        "Redistribute information for Application routes.";

      list application-route {
        key "instance-name";
        description "Redistribute application routes";
        leaf instance-name {
          type xr:Cisco-ios-xr-string;
          description "OnePK application name";
        }
        leaf default-metric {
          type Bgp-default-metric-range;
          description "Default metric";
        }
        leaf route-policy-name {
          type string;
          description "Route policy name";
        }
        leaf not-used {
          type uint32 {
            range "0..127";
          }
          description "Not used";
        }
      }
    }
  }

  grouping DEFAULT-INFO-ORIGINATE {
    description "Common node of global, vrf-global";
    leaf default-info-originate {
      type empty;
      description "Control distribution of default information";
    }
  }

  grouping ENFORCE-FIRST-AS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf enforce-first-as {
      type boolean;
      description
        "TRUE to enforce first AS; FALSE to not enforce
        first AS.";
    }
  }

  grouping SOFT-RECONFIGURATION {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container soft-reconfiguration {
      description
        "Enable/disable inbound soft reconfiguration for
        this neighbor/neighbor-group/af-group";
      leaf inbound-soft {
        type boolean;
        default "false";
        description
          "FALSE to prohibit inbound soft reconfiguration.
          TRUE otherwise.";
      }
      leaf soft-always {
        type boolean;
        default "false";
        description
          "TRUE to always use soft reconfig, even if route
          refresh is supported.  FALSE otherwise.";
      }
    }
  }

  grouping NEIGHBOR-GRACEFUL-RESTART {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf neighbor-graceful-restart {
      type boolean;
      description
        "TRUE to Enable graceful restart support for
        neighbor.  FALSE to disable graceful restart
        support for neighbor.";
    }
  }

  grouping ADVERTISE-DEF-IMP-DISABLE-V4 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-def-imp-disable-v4 {
      description
        "Disable Advertise Of Default VRF Imported Routes";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf adv-option {
        type Bgp-reorg-opt;
        description "Advertise option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping ADVERTISE-DEF-IMP-DISABLE-V6 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-def-imp-disable-v6 {
      description
        "Disable Advertise Of Default VRF Imported Routes";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf adv-option {
        type Bgp-reorg-opt;
        description "Advertise option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping LOCAL-ADDRESS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container local-address {
      description "Local ip address";
      leaf local-address-disable {
        type boolean;
        description
          "TRUE to prevent this entity from having a local
          address if the parent has one.FALSE to specify
          local ip address";
      }
      leaf local-ip-address {
        when "../local-address-disable = 'false'" {
          description "../LocalAddressDisable = 0";
        }
        type inet:ip-address-no-zone;
        description "Local ip address for neighbor";
      }
    }
  }

  grouping AS-OVERRIDE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf as-override {
      type boolean;
      default "true";
      description
        "TRUE to override matching AS-number while
        sending update. FALSE to prevent as-override
        from being inherited from the parent";
    }
  }

  grouping IGNORE-CONNECTED-CHECK-EBGP {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-afCommon node of
      neighbor-group, neighbor, vrf-neighbor,
      session-group";
    leaf ignore-connected-check-ebgp {
      type boolean;
      description
        "TRUE to disable the connected nexthop check for
        this peer.FALSE to enable the connected nexthop
        check for this peer.";
    }
  }

  grouping REMOTE-AS-LIST {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf remote-as-list {
      type string;
      description "Remote-as-list group name";
    }
  }

  grouping SEND-MULTICAST-ATTR {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-af";
    leaf send-multicast-attr {
      type Bgp-send-mcast-attr-cfg;
      description
        "Config send multicast attribute for this
        neighbor";
    }
  }

  grouping ENCAPSULATION-TYPE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-afCommon node of neighbor-group-af,
      neighbor-af, vrf-neighbor-af, af-group-af";
    leaf encapsulation-type {
      type Bgp-af-encapsulation;
      description "Encapsulation type for this neighbor";
    }
  }

  grouping ADVERTISE-PERMANENT-NETWORK {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf advertise-permanent-network {
      type empty;
      description "Advertise Permanent Networks to the peer";
    }
  }

  grouping BEST-PATH-COST-COMMUNITY {
    description "Common node of global, vrf-global";
    leaf best-path-cost-community {
      type empty;
      description
        "Change default route selection criteria to
        ignore cost community comparison";
    }
  }

  grouping RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-af";
    leaf rpki-bestpath-origin-as-allow-invalid {
      type empty;
      description "RPKI bestpath origin-AS allow invalid";
    }
  }

  grouping BGP-CFG-RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-afCommon node of neighbor-group,
      neighbor, session-group";
    leaf rpki-bestpath-origin-as-allow-invalid {
      type empty;
      description "RPKI bestpath origin-AS allow invalid";
    }
  }

  grouping NEIGHBOR-GRACEFUL-RESTART-TIME {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf neighbor-graceful-restart-time {
      type uint32 {
        range "1..4095";
      }
      units "second";
      default "120";
      description "Restart time advertised to neighbor";
    }
  }

  grouping TOS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container tos {
      description "TOS (Type Of Service)";
      leaf type {
        type dt1:Bgp-tos;
        description "Set type of service";
      }
      leaf value {
        type dt1:Bgp-precedence-dscp;
        description "TOS value to set";
      }
    }
  }

  grouping NEIGHBOR-CLUSTER-ID {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container neighbor-cluster-id {
      description "Neighbor Cluster-id";
      leaf cluster-id-number {
        type uint32 {
          range "1..4294967295";
        }
        description "Route-Reflector Cluster ID as 32 bit quantity";
      }
      leaf cluster-id-address {
        type inet:ipv4-address-no-zone;
        description
          "Route-Reflector Cluster ID in IPV4 address
          format";
      }
    }
  }

  grouping ACTIVATE {
    description
      "Common node of neighbor-af, vrf-neighbor-af,
      neighbor-group-af";
    leaf activate {
      type empty;
      description
        "Activate an address family for this neighbor.
        Deletion of this object causes deletion of all
        the objects under
        NeighborAF/VRFNeighborAF/NeighborGroupAF
        associated with this object.";
    }
  }

  grouping NEXT-HOP-SELF {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf next-hop-self {
      type boolean;
      description
        "Disable the next hop calculation and  insert
        your own address in the nexthop field of
        advertised routes you learned from the neighbor.";
    }
  }

  grouping ALLOW-AS-IN {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf allow-as-in {
      type uint32 {
        range "1..10";
      }
      default "3";
      description "Allow as-path with my AS present in it";
    }
  }

  grouping ADVERTISE-LOCAL-V4 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-local-v4 {
      description
        "Advertise Of Local Routes to the peer with
        different RT";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping ADVERTISE-LOCAL-V6 {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-local-v6 {
      description
        "Advertise Of Local Routes to the peer with
        different RT";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping BEST-EXTERNAL {
    description "Common node of global-af, vrf-global-af";
    leaf best-external {
      type boolean;
      description
        "TRUE to enable BE FALSE to disable BE
        inheritance from a parent";
    }
  }

  grouping ATTRIBUTE-DOWNLOAD {
    description "Common node of global-af, vrf-global-af";
    leaf attribute-download {
      type empty;
      description "Attribute download configuration";
    }
  }

  grouping ADDITIONAL-PATHS-SELECTION {
    description "Common node of global-af, vrf-global-af";

    container additional-paths-selection {
      description "Configure additional paths selection";
      leaf selection {
        type dt1:Bgpaf-additional-paths-cfg;
        description "Enable/disable selection ";
      }
      leaf route-policy-name {
        type string;
        description "Route policy for selection";
      }
    }
  }

  grouping NEIGHBOR-AF-LONG-LIVED-GRACEFUL-RESTART-CAPABLE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf neighbor-af-long-lived-graceful-restart-capable {
      type boolean;
      default "false";
      description
        "TRUE to treat neighbor as Long-lived
        Graceful-restart capable. FALSE to rely on
        capability negotiation.";
    }
  }

  grouping BEST-PATH-AS-MULTIPATH-RELAX {
    description "Common node of global, vrf-global";
    leaf best-path-as-multipath-relax {
      type empty;
      description
        "Change default multi-route selection criteria to
        relax as-path checking - only require same
        aspath length";
    }
  }

  grouping GLOBAL-TIMERS {
    description "Common node of global, vrf-global";

    container global-timers {
      description "Adjust routing timers.";
      leaf keepalive {
        type uint32 {
          range "0..65535";
        }
        units "second";
        default "60";
        description "Keepalive interval (seconds)";
      }
      leaf hold-time {
        type uint32 {
          range "0..65535";
        }
        units "second";
        default "180";
        description
          "Hold time (seconds).  Specify 0 to disable
          keepalives/hold time";
      }
      leaf min-accept-hold-time {
        type uint32 {
          range "0..65535";
        }
        units "second";
        default "3";
        description
          "Minimum acceptable hold time (seconds). Specify
          0 to disable keepalives/hold time";
      }
    }
  }

  grouping NEIGHBOR-GROUP-ADD-MEMBER {
    description "Common node of neighbor, vrf-neighbor";
    leaf neighbor-group-add-member {
      type string;
      description "Inherit configuration from a neighbor-group";
    }
  }

  grouping MOBILE-ROUTES {
    description "Common node of global-af, vrf-global-af";

    container mobile-routes {
      presence "enable mobile-routes";
      description "Redistribute mobile routes";
      leaf default-metric {
        type Bgp-default-metric-range;
        description "Default metric";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
      leaf not-used {
        type uint32 {
          range "0..127";
        }
        description "Not used";
      }
    }
  }

  grouping LOCAL-PREFERENCE {
    description "Common node of global, vrf-global";
    leaf local-preference {
      type uint32 {
        range "0..4294967295";
      }
      default "100";
      description "Configure default local preference";
    }
  }

  grouping CREATE {
    description "Common node of neighbor-group, session-group";
    leaf create {
      type empty;
      description
        "Create this group. Deletion of this object
        causes deletion of all the objects under
        NeighborGroup/SessionGroup associated with this
        object.";
    }
  }

  grouping EBGP-SEND-DMZ-ENABLE-MODES {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf ebgp-send-dmz-enable-modes {
      type Bgp-ebgp-send-dmz-enable-mode;
      description
        "Default mode, Cumulative mode or Disable to
        prevent inheritance from a parent";
    }
  }

  grouping SEND-SOCKET-BUFFER-SIZES {
    description "Common node of global, vrf-global";

    container send-socket-buffer-sizes {
      description "set socket parameters";
      leaf socket-send-size {
        type uint32 {
          range "4096..131072";
        }
        units "byte";
        default "24576";
        description "Send socket buffer size in bytes";
      }
      leaf bgp-send-size {
        type uint32 {
          range "4096..131072";
        }
        units "byte";
        default "4096";
        description "BGP Write buffer size in bytes";
      }
    }
  }

  grouping RECEIVE-SOCKET-BUFFER-SIZES {
    description
      "Common node of global, vrf-globalCommon node of
      global, vrf-global";

    container receive-socket-buffer-sizes {
      description "Set socket and BGP receive buffer sizes";
      leaf socket-receive-size {
        type uint32 {
          range "512..131072";
        }
        units "byte";
        default "32768";
        description "Receive socket buffer size in bytes";
      }
      leaf bgp-receive-size {
        type uint32 {
          range "512..131072";
        }
        units "byte";
        default "4096";
        description "BGP Read buffer size in bytes";
      }
    }
  }

  grouping BFD-ENABLE-MODES {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf bfd-enable-modes {
      type Bgp-bfd-enable-mode;
      description
        "Strict mode, Default mode or Disable to prevent
        inheritance from a parent";
    }
  }

  grouping RESET-WEIGHT-ON-IMPORT {
    description "Common node of global-af, vrf-global-af";
    leaf reset-weight-on-import {
      type boolean;
      description
        "TRUE to reset weight on import. FALSE to not
        reset and to prevent inheritance from a parent";
    }
  }

  grouping AGGREGATE-ADDRESS-TABLE {
    description "Common node of global-af, vrf-global-af";

    container aggregate-addresses {
      description "Configure BGP aggregate entries";

      list aggregate-address {
        key "aggregate-addr aggregate-prefix";
        description "Aggregate address configuration";
        leaf aggregate-addr {
          type inet:ip-address;
          description
            "Aggregate in prefix/length format (address
            part)";
        }
        leaf aggregate-prefix {
          type uint16 {
            range "0..128";
          }
          description
            "Aggregate in prefix/length format (prefix
            part)";
        }
        leaf generate-set-info {
          type boolean;
          description
            "TRUE to generate AS set path information,
            FALSE otherwise";
        }
        leaf generate-confederation-set-info {
          type boolean;
          description
            "TRUE to generate AS confederation set path
            information, FALSE otherwise";
        }
        leaf summary-only {
          type boolean;
          description
            "TRUE to filter more specific routes from
            updates, FALSEotherwise";
        }
        leaf route-policy-name {
          type string;
          description
            "Route policy on which to condition
            advertisement, suppression, and attributes";
        }
      }
    }
  }

  grouping EBGP-MULTIHOP {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container ebgp-multihop {
      description
        "Allow EBGP neighbors not on directly connected
        networks";
      leaf max-hop-count {
        type uint32 {
          range "1..255";
        }
        default "255";
        description "Maximum hop count";
      }
      leaf mpls-deactivation {
        type boolean;
        default "false";
        description "TRUE to not enable MPLS and NULL rewrite.";
      }
    }
  }

  grouping NEIGHBOR-GRACEFUL-RESTART-STALEPATH-TIME {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf neighbor-graceful-restart-stalepath-time {
      type uint32 {
        range "1..4095";
      }
      units "second";
      default "360";
      description
        "Maximum time to wait for restart of GR capable
        peer";
    }
  }

  grouping BEST-PATH-AIGP-IGNORE {
    description "Common node of global, vrf-global";
    leaf best-path-aigp-ignore {
      type empty;
      description
        "Change default route selection criteria to
        ignore AIGP unless both paths whichare compared
        have AIGP attribute";
    }
  }

  grouping SESSION-GROUP-ADD-MEMBER {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor";
    leaf session-group-add-member {
      type string;
      description
        "Inherit address-family independent config from a
        session-group";
    }
  }

  grouping BFD-MULTIPLIER {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf bfd-multiplier {
      type uint32 {
        range "2..16";
      }
      description
        "Detection multiplier for BFD sessions created by
        BGP";
    }
  }

  grouping FLOWSPEC-VALIDATION {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf flowspec-validation {
      type Bgp-flowspec-validation-cfg;
      description "Config Flowspec validation for this neighbor";
    }
  }

  grouping TTL-SECURITY {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf ttl-security {
      type boolean;
      description
        "TRUE to enable BGP TTL Security.  FALSE to not
        enable it and to prevent inheritance from a
        parent";
    }
  }

  grouping BEST-PATH-MED-ALWAYS {
    description "Common node of global, vrf-global";
    leaf best-path-med-always {
      type empty;
      description
        "Change default route selection criteria and
        allow comparing of MED from different neighbors";
    }
  }

  grouping MAX-PEERS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf max-peers {
      type uint32 {
        range "1..4096";
      }
      description "Set Maximum Peers in Dynamic Range";
    }
  }

  grouping SEND-COMMUNITY-EBGP-GRACEFUL-SHUTDOWN {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf send-community-ebgp-graceful-shutdown {
      type boolean;
      description
        "TRUE to send communities to the external
        neighbor/neighbor-group/af-group.  FALSE not to
        send and to prevent inheritance from a parent";
    }
  }

  grouping DISABLE-MSG-LOG {
    description "Common node of global, vrf-global";
    leaf disable-msg-log {
      type empty;
      description
        "Disable inbound and outbound messagelogging for
        all neighbors under the vrf";
    }
  }

  grouping LOCAL-AS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container local-as {
      description "Specify a local-as number";
      leaf as-xx {
        type dt1:Bgp-as-range;
        must "../as-yy and not(../disable)";
        description "xx of AS number xx.yy";
      }
      leaf as-yy {
        type dt1:Bgp-as-range;
        must "../as-xx and not(../disable)";
        description "yy of AS number xx.yy";
      }
      leaf no-prepend {
        type empty;
        must "../as-xx and ../as-yy and not(../disable)";
        description
          "Do not prepend Local AS to announcements from
          this neighbor";
      }
      leaf disable {
        type empty;
        must "not(../as-xx or ../as-yy or ../no-prepend or ../replace-as or ../dual-as)";
        description
          "Disable Local AS and prevent it from being
          inherited from a parent";
      }
      leaf replace-as {
        type empty;
        must "../as-xx and ../as-yy and ../no-prepend and not(../disable)";
        description
          "Prepend only Local AS to announcements from
          this neighbor";
      }
      leaf dual-as {
        type empty;
        must "../as-xx and ../as-yy and ../no-prepend and ../replace-as and not(../disable)";
        description "Dual-AS mode";
      }
    }
  }

  grouping LISP-ROUTES {
    description "Common node of global-af, vrf-global-af";

    container lisp-routes {
      presence "enable lisp-routes";
      description "Redistribute lisp routes";
      leaf default-metric {
        type Bgp-default-metric-range;
        description "Default metric";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
    }
  }

  grouping ADDITIONAL-PATHS-SEND-CAPABILITY {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf additional-paths-send-capability {
      type dt1:Bgp-nbr-cap-additional-paths-cfg;
      description "Advertise additional paths Send capability";
    }
  }

  grouping L2VPN-SIGNALLING {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-af";
    leaf l2vpn-signalling {
      type Bgp-signal;
      description "Disable signalling type on the peer";
    }
  }

  grouping DAMPENING {
    description "Common node of global-af, vrf-global-af";

    container dampening {
      presence "enable dampening";
      description "Enable route-flap dampening";
      leaf half-life {
        type uint32 {
          range "1..45";
        }
        units "minute";
        description "Half-life time for the penalty (minutes).";
      }
      leaf reuse-threshold {
        type uint32 {
          range "1..20000";
        }
        description "Value to start reusing a route.";
      }
      leaf suppress-threshold {
        type uint32 {
          range "1..20000";
        }
        description "Value to start suppressing a route.";
      }
      leaf suppress-time {
        type uint32 {
          range "1..255";
        }
        units "second";
        description
          "Maximum duration to suppress a stable route
          (seconds).";
      }
      leaf route-policy-name {
        type string;
        description
          "Route policy to specify criteria for dampening.
          This cannot be specified if any other
          parameters are specified.";
      }
    }
  }

  grouping ADVERTISE-LOCAL-LABELED-ROUTE-SAFI-UNICAST {
    description "Common node of global-af, vrf-global-af";
    leaf advertise-local-labeled-route-safi-unicast {
      type dt1:Bgp-advertise-local-labeled-route-cfg;
      description
        "Enable/disable advertisement of routes with
        local-label via Unicast SAFI";
    }
  }

  grouping SUBSCRIBER-ROUTES {
    description "Common node of global-af, vrf-global-af";

    container subscriber-routes {
      presence "enable subscriber-routes";
      description "Redistribute subscriber routes";
      leaf default-metric {
        type Bgp-default-metric-range;
        description "Default metric";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
      leaf not-used {
        type uint32 {
          range "0..127";
        }
        description "Not used";
      }
    }
  }

  grouping INTERNAL-VPN-CLIENT-IBGPCE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf internal-vpn-client-ibgpce {
      type boolean;
      description
        "TRUE to preserve the CE path attributes.FALSE to
        override CE path attributes.";
    }
  }

  grouping ACCEPT-ROUTE-LEGACY-RT {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf accept-route-legacy-rt {
      type boolean;
      description
        "TRUE to configure as a accept-route-legacy-RT. 
        FALSE to prevent accept-route-legacy-RT from
        being inherited.";
    }
  }

  grouping PERMANENT-NETWORK {
    description "Common node of global-af, vrf-global-af";
    leaf permanent-network {
      type string;
      description "Route policy for permanent networks";
    }
  }

  grouping ENABLE {
    description "Common node of global-af, vrf-global-af";
    leaf enable {
      type empty;
      description
        "Enable the address family. Deletion of this
        object causes deletion of all the objects under
        GlobalAF/VRFGlobalAF associated with this object
        .";
    }
  }

  grouping EBGP-RECV-DMZ {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf ebgp-recv-dmz {
      type boolean;
      description
        "TRUE to receive DMZ link bandwidth from ebgp
        peer. FALSE to not receive from ebgp peer and to
        prevent inheritance from a parent";
    }
  }

  grouping ADVERTISEMENT-INTERVAL {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container advertisement-interval {
      presence "Indicates a advertisement-interval node is"+
        " configured.";
      description
        "Minimum interval between sending BGP routing
        updates";
      leaf minimum-interval {
        type uint32 {
          range "0..600";
        }
        units "second";
        mandatory true;
        description
          "Minimum advertisement interval time, secs part";
      }
      leaf minimum-interval-msecs {
        type uint32 {
          range "0..999";
        }
        units "millisecond";
        description
          "Minimum advertisement interval time, msecs part";
      }
    }
  }

  grouping IMPORT {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container import {
      description
        "Import Reorigination options for Routes from the
        peer";
      leaf import-stitching {
        type boolean;
        description
          "TRUE to Import with Stitching RTs, FALSE to
          Import with normal RTs";
      }
      leaf import-reoriginate {
        type boolean;
        description
          "TRUE to Reoriginate imported routes, FALSE to
          not Reoriginate imported routes - not supported";
      }
      leaf import-reoriginate-stitching {
        type boolean;
        description
          "TRUE to Reoriginate imported routes with
          Stitching RTs, FALSE to Reoriginate imported
          routes with normal RTs";
      }
    }
  }

  grouping ACCEPT-OWN {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf accept-own {
      type boolean;
      description
        "Handle self-originated routes with Accept-Own
        community. Valid for following neighbor
        address-families: VPNv4Unicast, VPNv6Unicast.";
    }
  }

  grouping ADDITIONAL-PATHS-RECEIVE {
    description "Common node of global-af, vrf-global-af";
    leaf additional-paths-receive {
      type dt1:Bgpaf-additional-paths-cfg;
      description "Advertise additional paths Receive capability";
    }
  }

  grouping MPLS-ACTIVATED-INTERFACE-TABLE {
    description "Common node of global, vrf-global";

    container mpls-activated-interfaces {
      description "Configure list of MPLS activated interfaces";

      list mpls-activated-interface {
        key "interface-name";
        description "Configure a MPLS activated interface";
        leaf interface-name {
          type xr:Interface-name;
          description "Interface Name";
        }
      }
    }
  }

  grouping MULTIPATH {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf multipath {
      type empty;
      description
        "Allow paths from this neighbor to be eligible
        for selective multipath";
    }
  }

  grouping EIGRP-ROUTE-TABLE {
    description "Common node of global-af, vrf-global-af";

    container eigrp-routes {
      description "Redistribute information for EIGRP routes.";

      list eigrp-route {
        key "instance-name";
        description "Redistribute EIGRP routes";
        leaf instance-name {
          type xr:Cisco-ios-xr-string;
          description "EIGRP router tag";
        }
        leaf default-metric {
          type Bgp-default-metric-range;
          description "Default metric";
        }
        leaf route-policy-name {
          type string;
          description "Route policy name";
        }
        leaf redist-type {
          type xr:Hex-integer;
          description
            "Redistribution type: 01 for internal routes,
            02 for external routes, Logical combinations
            permitted.";
        }
      }
    }
  }

  grouping ROUTE-REFLECTOR-CLIENT {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf route-reflector-client {
      type boolean;
      description
        "TRUE to configure as a route-reflector-client. 
        FALSE to prevent route-reflector-client from
        being inherited.";
    }
  }

  grouping ADVERTISE-LOCAL-LABELED-ROUTE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf advertise-local-labeled-route {
      type dt1:Bgp-advertise-local-labeled-route-cfg;
      description
        "Enable/disable advertisement of routes with
        local-label";
    }
  }

  grouping SESSION-OPEN-MODE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf session-open-mode {
      type Bgp-tcp-mode;
      default "either";
      description "TCP mode to be used to establish BGP session";
    }
  }

  grouping STATIC-ROUTES {
    description "Common node of global-af, vrf-global-af";

    container static-routes {
      presence "enable static-routes";
      description "Redistribute static routes";
      leaf default-metric {
        type Bgp-default-metric-range;
        description "Default metric";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
      leaf not-used {
        type uint32 {
          range "0..127";
        }
        description "Not used";
      }
    }
  }

  grouping PASSWORD {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container password {
      description "Set or disable a password";
      leaf password-disable {
        type boolean;
        description
          "TRUE to prevent this entity from having a
          password even if the parent has one.  FALSEto
          specify a password";
      }
      leaf password {
        when "../password-disable = 'false'" {
          description "../PasswordDisable = 0";
        }
        type xr:Proprietary-password;
        description
          "The neighbor password.  Leave unspecified when
          disabling the password.";
      }
    }
  }

  grouping NEXT-HOP-UNCHANGED-MULTIPATH {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-groupCommon node of
      neighbor-group-af, neighbor-af, vrf-neighbor-af,
      af-group-af";
    leaf next-hop-unchanged-multipath {
      type boolean;
      description
        "TRUE to disable overwriting of next hop for
        multipaths. FALSE to prevent next-hop-unchanged
        for multipaths.";
    }
  }

  grouping NEXT-HOP-RESOLUTION-PREFIX-LENGTH-MINIMUM {
    description "Common node of global-af, vrf-global-af";
    leaf next-hop-resolution-prefix-length-minimum {
      type uint32 {
        range "0..128";
      }
      default "0";
      description "Minimum prefix-length for nexthop resolution";
    }
  }

  grouping BEST-PATH-AS-PATH-LENGTH {
    description "Common node of global, vrf-global";
    leaf best-path-as-path-length {
      type empty;
      description
        "Change default route selection criteria to
        ignore AS path length";
    }
  }

  grouping MSG-LOG-OUT {
    description
      "Common node of global, vrf-globalCommon node of
      neighbor-group, neighbor, vrf-neighbor,
      session-group";

    container msg-log-out {
      description "Message log outbound";
      leaf msg-buf-count {
        type uint32 {
          range "1..100";
        }
        description "Outbound message log buffer size";
      }
      leaf msg-log-disable {
        type boolean;
        description "Disable inbound message logging";
      }
      leaf msg-log-inherit-disable {
        type boolean;
        description
          "TRUE, to prevent this entity from having a
          outbound message logging if parent has one";
      }
    }
  }

  grouping PREFIX-ORF-POLICY {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf prefix-orf-policy {
      type string;
      description "Prefix ORF policy name for incoming updates";
    }
  }

  grouping SOURCED-NETWORK-TABLE {
    description "Common node of global-af, vrf-global-af";

    container sourced-networks {
      description "Specify a network to announce via BGP";

      list sourced-network {
        key "network-addr network-prefix";
        description "Sourced network configuration";
        leaf network-addr {
          type inet:ip-address;
          description
            "Network in prefix/length format (address part)";
        }
        leaf network-prefix {
          type uint16 {
            range "0..128";
          }
          description
            "Network in prefix/length format (prefix part)";
        }
        leaf backdoor {
          type boolean;
          description
            "Specify a BGP backdoor route, default is FALSE";
        }
        leaf route-policy-name {
          type string;
          description "Route policy name";
        }
      }
    }
  }

  grouping REMOVE-PRIVATE-AS-ENTIRE-AS-PATH {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container remove-private-as-entire-as-path {
      presence "Indicates a remove-private-as-entire-as-path node"+
        " is configured.";
      description "Remove private AS number from outbound updates";
      leaf enable {
        type boolean;
        mandatory true;
        description
          "TRUE to remove private AS from outbound updates
          .  FALSE to prevent remove-private-AS from
          being inherited.";
      }
      leaf entire {
        type boolean;
        description
          "TRUE to remove private AS from outbound updates
          if all ASes in aspath areprivate. FALSE to
          prevent remove-private-ASfrom being inherited.";
      }
    }
  }

  grouping GRACEFUL-MAINTENANCE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container graceful-maintenance {
      description "Graceful Maintenance mode";

      container graceful-maintenance-local-preference {
        description "Set Local Preference to advertise routes with";
        leaf gshut-loc-pref-disable {
          type boolean;
          description
            "TRUE, to prevent inheritance of Local Pref
            value from its parents.FALSE, otherwise";
        }
        leaf local-preference {
          type uint32 {
            range "0..4294967295";
          }
          description "Local Preference Value";
        }
      }

      container graceful-maintenance-as-prepends {
        description
          "Number of times to prepend local AS number to
          the AS path";
        leaf gshut-prepends-disable {
          type boolean;
          description
            "TRUE, to prevent inheritance of AS Prepends
            value from its parents.FALSE, otherwise";
        }
        leaf as-prepends {
          type uint32 {
            range "0..6";
          }
          description "number of times AS prepends";
        }
      }
      leaf enable {
        type empty;
        description
          "Enter Graceful Maintenance mode to configure
          parametrs";
      }
      leaf graceful-maintenance-activate {
        type boolean;
        description "Initiate the graceful shutdown procedure";
      }
    }
  }

  grouping NEIGHBOR-AF-LONG-LIVED-GRACEFUL-RESTART-STALE-TIME {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container neighbor-af-long-lived-graceful-restart-stale-time {
      description
        "Maximum time to wait before purging long lived
        routes";
      leaf stale-time-send {
        type uint32 {
          range "0..16777215";
        }
        units "second";
        default "0";
        description "Max time (seconds)";
      }
      leaf stale-time-accept {
        type uint32 {
          range "0..16777215";
        }
        units "second";
        default "0";
        description "Max time (seconds)";
      }
    }
  }

  grouping BFD {
    description "Common node of global, vrf-global";

    container bfd {
      description "BFD configuration";
      leaf detection-multiplier {
        type uint32 {
          range "2..16";
        }
        description
          "Detection multiplier for BFD sessions created
          by BGP";
      }
      leaf interval {
        type uint32 {
          range "3..30000";
        }
        units "millisecond";
        description
          "Hello interval for BFD sessions created by BGP";
      }
    }
  }

  grouping ALLOCATE-LABEL {
    description "Common node of global-af, vrf-global-af";

    container allocate-label {
      description "Label allocation policy";
      leaf all {
        type boolean;
        description
          "Whether all nets should be labeled, default is
          FALSE";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
    }
  }

  grouping SEND-BUFFER-SIZE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container send-buffer-size {
      description
        "Set socket send buffer size and BGP write buffer
        size";
      leaf socket-send-size {
        type uint32 {
          range "4096..131072";
        }
        units "byte";
        default "24576";
        description "Send socket buffer size in bytes";
      }
      leaf bgp-send-size {
        type uint32 {
          range "4096..131072";
        }
        units "byte";
        default "4096";
        description "BGP write buffer size in bytes";
      }
    }
  }

  grouping BEST-PATH-MED-MISSING {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-groupCommon node of global,
      vrf-global";
    leaf best-path-med-missing {
      type empty;
      description "Treat missing MED as the least preferred one";
    }
  }

  grouping SUPPRESS-ALL-CAPABILITIES {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf suppress-all-capabilities {
      type boolean;
      description
        "TRUE to suppress all capabilities. FALSE to not
        suppress and to prevent inheritance from a
        parent";
    }
  }

  grouping DEFAULT-WEIGHT {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-groupCommon node of
      neighbor-group-af, neighbor-af, vrf-neighbor-af,
      af-group-af";
    leaf default-weight {
      type uint32 {
        range "0..65535";
      }
      description
        "Set default weight for routes from this
        neighbor/neighbor-group/af-group";
    }
  }

  grouping SUPPRESS-FOUR-BYTE-AS-CAPABILITY {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf suppress-four-byte-as-capability {
      type boolean;
      description
        "TRUE to suppress BGP 4-byte-as capability. 
        FALSE to not suppress it and to prevent
        inheritance from a parent";
    }
  }

  grouping ADVERTISE-LOCAL-L2VPNEVPN {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-local-l2vpnevpn {
      description
        "Advertise Of Local Routes to the peer with
        different RT";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping EGRESS-PEER-ENGINEERING {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf egress-peer-engineering {
      type boolean;
      description
        "TRUE to enable egress peer engineering FALSE to
        disable egress peer engineering and to prevent
        inheritance from a parent";
    }
  }

  grouping BEST-PATH-CONFEDERATION-PATHS {
    description "Common node of global, vrf-global";
    leaf best-path-confederation-paths {
      type empty;
      description
        "Change default route selection criteria and
        allow the comparing of MED among confederation
        paths";
    }
  }

  grouping DYNAMIC-MED-INTERVAL {
    description "Common node of global-af, vrf-global-af";
    leaf dynamic-med-interval {
      type uint32 {
        range "0..10";
      }
      units "minute";
      default "10";
      description
        "Update generation delay (in minutes) after a MED
        change";
    }
  }

  grouping REMOVE-PRIVATE-AS-ENTIRE-AS-PATH-INBOUND {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container remove-private-as-entire-as-path-inbound {
      presence "Indicates a"+
        " remove-private-as-entire-as-path-inbound node is"+
        " configured.";
      description "Remove private AS number from inbound updates";
      leaf enable {
        type boolean;
        mandatory true;
        description
          "TRUE to remove private AS from inbound updates.
          FALSE to prevent remove-private-AS from being
          inherited.";
      }
      leaf entire {
        type boolean;
        description
          "TRUE to remove private AS from inbound updates
          if all ASes in aspath areprivate. FALSE to
          prevent remove-private-ASfrom being inherited.";
      }
    }
  }

  grouping CONNECTED-ROUTES {
    description "Common node of global-af, vrf-global-af";

    container connected-routes {
      presence "enable connected-routes";
      description "Redistribute connected routes";
      leaf default-metric {
        type Bgp-default-metric-range;
        description "Default metric";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
      leaf not-used {
        type uint32 {
          range "0..127";
        }
        description "Not used";
      }
    }
  }

  grouping IGP-REDIST-INTERNAL {
    description "Common node of global, vrf-global";
    leaf igp-redist-internal {
      type empty;
      description
        "Allow redistribution of iBGP into IGPs
        (dangerous)";
    }
  }

  grouping AIGP-SEND-MED {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf aigp-send-med {
      type Bgp-aigp-cfg;
      description "Enable/Disable sending AIGP in MED ";
    }
  }

  grouping AIGP {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf aigp {
      type Bgp-aigp-cfg;
      description
        "Enable Accumulated IGP Metric for this neighbor.";
    }
  }

  grouping ADVERTISE-ORF {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf advertise-orf {
      type Bgp-orf;
      default "none";
      description "Advertise ORF capability to the peer";
    }
  }

  grouping BFD-MINIMUM-INTERVAL {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf bfd-minimum-interval {
      type uint32 {
        range "3..30000";
      }
      units "millisecond";
      description "Hello interval for BFD sessions created by BGP";
    }
  }

  grouping AIGP-COST-COMMUNITY {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container aigp-cost-community {
      presence "Indicates a aigp-cost-community node is configured.";
      description "Send AIGP value in Cost Community. ";
      leaf enable {
        type boolean;
        mandatory true;
        description
          "TRUE to enable sending cost community, FALSE
          otherwise ";
      }
      leaf cost-community-id {
        type uint32 {
          range "0..255";
        }
        mandatory true;
        description "Cost Community ID";
      }
      leaf transitive {
        type boolean;
        description
          "True to send transitive cost community FALSE
          otherwise";
      }
      leaf cost-community-poi-type {
        type Bgp-aigp-cfg-poi;
        mandatory true;
        description "Cost Community POI";
      }
    }
  }

  grouping DISABLE-AS-PATH-LOOP-CHECK {
    description "Common node of global-af, vrf-global-af";
    leaf disable-as-path-loop-check {
      type empty;
      description "Disable outbound AS Path loop check";
    }
  }

  grouping BEST-PATH-ROUTER-ID {
    description "Common node of global, vrf-global";
    leaf best-path-router-id {
      type empty;
      description
        "Change default route selection criteria and
        compare router-id for identical EBGP paths";
    }
  }

  grouping RIP-ROUTES {
    description "Common node of global-af, vrf-global-af";

    container rip-routes {
      presence "enable rip-routes";
      description "Redistribute RIP routes";
      leaf default-metric {
        type Bgp-default-metric-range;
        description "Default metric";
      }
      leaf route-policy-name {
        type string;
        description "Route policy name";
      }
      leaf not-used {
        type uint32 {
          range "0..127";
        }
        description "Not used";
      }
    }
  }

  grouping DESCRIPTION {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";
    leaf description {
      type string;
      description "Up to 80 characters describing this neighbor";
    }
  }

  grouping ADVERTISE-L2VPNEVPN {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";

    container advertise-l2vpnevpn {
      description "Advertise Translated Routes to the peer";
      leaf af-name {
        type dt1:Bgp-address-family;
        description "Address family";
      }
      leaf reorg-option {
        type Bgp-reorg-opt;
        description "Reorigination option";
      }
      leaf rt-type {
        type Bgp-adv-rt;
        description "RT type";
      }
    }
  }

  grouping KEYCHAIN {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container keychain {
      description "Set or disable keychain based authentication";
      leaf keychain-disable {
        type boolean;
        description
          "TRUE to prevent this entity from having a
          keychain based authentication even if the
          parent has one.FALSE to specify a keychain name";
      }
      leaf keychain-name {
        when "../keychain-disable = 'false'" {
          description "../KeychainDisable = 0";
        }
        type string;
        description "Name of the keychain associated with neighbor";
      }
    }
  }

  grouping RECEIVE-BUFFER-SIZE {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container receive-buffer-size {
      description
        "Set socket receive buffer size and BGP read
        buffer size";
      leaf socket-receive-size {
        type uint32 {
          range "512..131072";
        }
        units "byte";
        default "32768";
        description "Receive socket buffer size in bytes";
      }
      leaf bgp-receive-size {
        type uint32 {
          range "512..131072";
        }
        units "byte";
        default "4096";
        description "BGP read buffer size in bytes";
      }
    }
  }

  grouping NEXT-HOP-UNCHANGED {
    description
      "Common node of neighbor-group-af, neighbor-af,
      vrf-neighbor-af, af-group-af";
    leaf next-hop-unchanged {
      type boolean;
      description
        "TRUE to disable overwriting of next hop before
        advertising to eBGP peers. FALSE to prevent
        next-hop-unchanged from being inherited.";
    }
  }

  grouping OSPF-ROUTE-TABLE {
    description "Common node of global-af, vrf-global-af";

    container ospf-routes {
      description "Redistribute information for OSPF routes.";

      list ospf-route {
        key "instance-name";
        description "Redistribute OSPF routes";
        leaf instance-name {
          type xr:Cisco-ios-xr-string;
          description "OSPF router tag";
        }
        leaf default-metric {
          type Bgp-default-metric-range;
          description "Default metric";
        }
        leaf route-policy-name {
          type string;
          description "Route policy name";
        }
        leaf redist-type {
          type xr:Hex-integer;
          description
            "Redistribution type: 01 for internal routes,
            02 for external routes of type 1, 04 for
            external routes of type 2, 08 for NSSA
            external routes of type 1, 10 for NSSA
            external routes of type 2, 20 for external
            routes, 40 for NSSA external routes.  Logical
            combinations permitted.";
        }
      }
    }
  }

  grouping ROUTER-ID {
    description "Common node of global, vrf-global";
    leaf router-id {
      type inet:ipv4-address-no-zone;
      default "0.0.0.0";
      description "Configure Router-id";
    }
  }

  grouping DEFAULT-METRIC {
    description "Common node of global, vrf-global";
    leaf default-metric {
      type uint32 {
        range "1..4294967295";
      }
      description "Default redistributed metric";
    }
  }

  grouping RPKI-ORIGIN-AS-VALIDATION-DISABLE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-af";
    leaf rpki-origin-as-validation-disable {
      type empty;
      description "RPKI origin-AS validation disable";
    }
  }

  grouping BGP-CFG-RPKI-ORIGIN-AS-VALIDATION-DISABLE {
    description
      "Common node of neighbor-group-af, neighbor-af,
      af-group-afCommon node of neighbor-group,
      neighbor, session-group";
    leaf rpki-origin-as-validation-disable {
      type empty;
      description "RPKI origin-AS validation disable";
    }
  }

  grouping DISABLE-NEIGHBOR-LOGGING {
    description "Common node of global, vrf-global";
    leaf disable-neighbor-logging {
      type empty;
      description "Disable neighbor change logging";
    }
  }

  grouping TCPMSS {
    description
      "Common node of neighbor-group, neighbor,
      vrf-neighbor, session-group";

    container tcpmss {
      description "TCP Maximum segment size";
      leaf tcpmss-disable {
        type boolean;
        description
          "TRUE, to prevent inheritance ofTCP MSS
          valuefrom its parents.FALSE, otherwise";
      }
      leaf mss {
        type uint32 {
          range "68..10000";
        }
        description "Maximum Segment Size";
      }
    }
  }

  container bgp {
    description "BGP configuration commands";

    list instance {
      key "instance-name";
      description "BGP instance configuration commands";
      leaf instance-name {
        type xr:Cisco-ios-xr-string;
        description
          "Instance Name. For Default instance use -
          default";
      }

      list instance-as {
        key "as";
        description "Autonomous system";
        leaf as {
          type dt1:Bgp-as-range;
          description
            "Higher 16 bits of 4-byte Autonomous system
            number";
        }

        list four-byte-as {
          key "as";
          description "4-byte Autonomous system";

          container vrfs {
            description "VRF config";

            list vrf {
              key "vrf-name";
              description "VRF config";

              container vrf-global {
                description "VRF attribute config";

                container route-distinguisher {
                  description "Route distinguisher";
                  leaf type {
                    type Bgp-route-distinguisher;
                    description "Type of RD";
                  }
                  leaf as-xx {
                    when "../type = 'as' or ../type ="+
                      " 'four-byte-as'" {
                        description
                          "../Type = AS or ../Type = FourByteAS";
                    }
                    type dt1:Bgp-as-range;
                    description "AS number";
                  }
                  leaf as {
                    when "../type = 'as' or ../type ="+
                      " 'four-byte-as'" {
                        description
                          "../Type = AS or ../Type = FourByteAS";
                    }
                    type dt1:Bgp-as-range;
                    description "AS number";
                  }
                  leaf as-index {
                    when "../type = 'as' or ../type ="+
                      " 'four-byte-as'" {
                        description
                          "../Type = AS or ../Type = FourByteAS";
                    }
                    type dt1:Bgp-extcomm-asn-index;
                    description "ASN Index";
                  }
                  leaf address {
                    when "../type = 'ipv4-address'" {
                      description "../Type = IPV4Address";
                    }
                    type inet:ipv4-address-no-zone;
                    description "IP address";
                  }
                  leaf address-index {
                    when "../type = 'ipv4-address'" {
                      description "../Type = IPV4Address";
                    }
                    type dt1:Bgp-extcomm-v4-addr-index;
                    description "IP address index";
                  }
                }

                container vrf-global-afs {
                  description "Global VRF-specific configuration";

                  list vrf-global-af {
                    key "af-name";
                    description
                      "Global VRF AF-specific configuration";

                    container mvpn {
                      description "MVPN configurations";
                      leaf single-forwarder-selection {
                        type Bgp-mvpn-sfs-select;
                        description
                          "Select MVPN single forwarder selection";
                      }
                    }

                    container ebgp {
                      presence "Indicates a ebgp node is"+
                        " configured.";
                      description "Use eBGP multipaths";
                      leaf paths-value {
                        type uint32 {
                          range "2..32";
                        }
                        mandatory true;
                        description "Number of paths";
                      }
                      leaf unequal-cost {
                        type boolean;
                        default "false";
                        description "UNUSED";
                      }
                      leaf selective {
                        type boolean;
                        default "false";
                        description
                          "Allow multipaths only from marked
                          neighbors";
                      }
                      leaf order-by-igp-metric {
                        type boolean;
                        default "false";
                        description
                          "Order candidate multipaths by IGP
                          metric";
                      }
                    }

                    container eibgp {
                      presence "Indicates a eibgp node is"+
                        " configured.";
                      description "Use eiBGP multipaths";
                      leaf paths-value {
                        type uint32 {
                          range "2..32";
                        }
                        mandatory true;
                        description "Number of paths";
                      }
                      leaf unequal-cost {
                        type boolean;
                        default "false";
                        description "UNUSED";
                      }
                      leaf selective {
                        type boolean;
                        default "false";
                        description
                          "Allow multipaths only from marked
                          neighbors";
                      }
                      leaf order-by-igp-metric {
                        type boolean;
                        default "false";
                        description
                          "Order candidate multipaths by IGP
                          metric";
                      }
                    }

                    container ibgp {
                      presence "Indicates a ibgp node is"+
                        " configured.";
                      description "Use iBGP multipaths";
                      leaf paths-value {
                        type uint32 {
                          range "2..32";
                        }
                        mandatory true;
                        description "Number of paths";
                      }
                      leaf unequal-cost {
                        type boolean;
                        default "false";
                        description
                          "Allow multipaths to have different IGP
                          metrics";
                      }
                      leaf selective {
                        type boolean;
                        default "false";
                        description
                          "Allow multipaths only from marked
                          neighbors";
                      }
                      leaf order-by-igp-metric {
                        type boolean;
                        default "false";
                        description
                          "Order candidate multipaths by IGP
                          metric";
                      }
                    }
                    leaf rt-download {
                      type empty;
                      description
                        "Route-Target download configuration";
                    }
                    leaf allow-vpn-default-originate {
                      type boolean;
                      description
                        "TRUE to send default orig route to VPN
                        neighborFALSE to not send default
                        originate route ";
                    }
                    leaf af-name {
                      type dt1:Bgp-address-family;
                      description "Address family";
                    }
                    uses AGGREGATE-ADDRESS-TABLE;
                    uses DYNAMIC-MED-INTERVAL;
                    uses DAMPENING;
                    uses ENABLE;
                    uses RIP-ROUTES;
                    uses LISP-ROUTES;
                    uses STATIC-ROUTES;
                    uses DISTANCE;
                    uses TABLE-POLICY;
                    uses APP-ROUTE-TABLE;
                    uses ATTRIBUTE-DOWNLOAD;
                    uses LABEL-MODE;
                    uses EIGRP-ROUTE-TABLE;
                    uses BEST-EXTERNAL;
                    uses SOURCED-NETWORK-TABLE;
                    uses CONNECTED-ROUTES;
                    uses ADDITIONAL-PATHS-RECEIVE;
                    uses PERMANENT-NETWORK;
                    uses ALLOCATE-LABEL;
                    uses ADDITIONAL-PATHS-SELECTION;
                    uses NEXT-HOP-RESOLUTION-PREFIX-LENGTH-MINIMUM;
                    uses RESET-WEIGHT-ON-IMPORT;
                    uses OSPF-ROUTE-TABLE;
                    uses ADDITIONAL-PATHS-SEND;
                    uses ADVERTISE-LOCAL-LABELED-ROUTE-SAFI-UNICAST;
                    uses MOBILE-ROUTES;
                    uses DISABLE-AS-PATH-LOOP-CHECK;
                    uses SUBSCRIBER-ROUTES;
                  }
                }
                leaf exists {
                  type empty;
                  description
                    "Create this VRF. Deletion of this object
                    causes deletion of all the objects under
                    VRF associated with this object.";
                }
                uses ROUTER-ID;
                uses DISABLE-ENFORCE-FIRST-AS;
                uses BEST-PATH-COST-COMMUNITY;
                uses BEST-PATH-AIGP-IGNORE;
                uses BEST-PATH-AS-PATH-LENGTH;
                uses IGP-REDIST-INTERNAL;
                uses MULTI-PATH-AS-PATH-IGNORE-ONWARDS;
                uses DISABLE-FAST-EXTERNAL-FALLOVER;
                uses DEFAULT-METRIC;
                uses DEFAULT-INFO-ORIGINATE;
                uses BEST-PATH-CONFEDERATION-PATHS;
                uses BEST-PATH-AS-MULTIPATH-RELAX;
                uses MPLS-ACTIVATED-INTERFACE-TABLE;
                uses DISABLE-AUTO-SOFT-RESET;
                uses DISABLE-MSG-LOG;
                uses GLOBAL-TIMERS;
                uses BFD;
                uses DISABLE-NEIGHBOR-LOGGING;
                uses SEND-SOCKET-BUFFER-SIZES;
                uses BEST-PATH-MED-ALWAYS;
                uses RECEIVE-SOCKET-BUFFER-SIZES;
                uses BEST-PATH-ROUTER-ID;
                uses BEST-PATH-MED-MISSING;
                uses LOCAL-PREFERENCE;
              }

              container vrf-neighbors {

                grouping VRF-NEIGHBOR-CONTENT {
                  description "VRF NEIGHBOR CONTENT";

                  container vrf-neighbor-afs {
                    description
                      "Address family type of a VRF neighbor";

                    list vrf-neighbor-af {
                      key "af-name";
                      description
                        "Address family type of a VRF neighbor";
                      leaf af-name {
                        type dt1:Bgp-address-family;
                        description "BGP neighbor address family";
                      }
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-CAPABLE";
                      uses SEND-EXT-COMMUNITY-EBGP;
                      uses ACCEPT-ROUTE-LEGACY-RT;
                      uses AIGP-COST-COMMUNITY;
                      uses SEND-COMMUNITY-EBGP;
                      uses ADVERTISE-DEF-IMP-DISABLE-V6;
                      uses ADVERTISE-DISABLE;
                      uses MAXIMUM-PREFIXES;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH-INBOUND;
                      uses NEXT-HOP-UNCHANGED;
                      uses ADVERTISE-LOCAL-LABELED-ROUTE;
                      uses ADVERTISE-DEF-IMP-DISABLE-V4;
                      uses FLOWSPEC-VALIDATION;
                      uses ADVERTISE-L2VPNEVPN;
                      uses ADVERTISE-LOCAL-L2VPNEVPN;
                      uses ENCAPSULATION-TYPE;
                      uses AS-OVERRIDE;
                      uses MULTIPATH;
                      uses SEND-COMMUNITY-EBGP-GRACEFUL-SHUTDOWN;
                      uses ACTIVATE;
                      uses PREFIX-ORF-POLICY;
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-STALE-TIME";
                      uses SITE-OF-ORIGIN;
                      uses AIGP;
                      uses AIGP-SEND-MED;
                      uses ADVERTISE-V6;
                      uses ALLOW-AS-IN;
                      uses ADVERTISE-ORF;
                      uses ROUTE-REFLECTOR-CLIENT;
                      uses NEXT-HOP-SELF;
                      uses ADVERTISE-LOCAL-V6;
                      uses ROUTE-POLICY-IN;
                      uses IMPORT;
                      uses DEFAULT-ORIGINATE;
                      uses SOFT-RECONFIGURATION;
                      uses ADVERTISE-VRF-IMP-DISABLE-V6;
                      uses DEFAULT-WEIGHT;
                      uses AF-GROUP;
                      uses ADVERTISE-V4;
                      uses NEXT-HOP-UNCHANGED-MULTIPATH;
                      uses ACCEPT-OWN;
                      uses ROUTE-POLICY-OUT;
                      uses ADVERTISE-LOCAL-V4;
                      uses ADVERTISE-PERMANENT-NETWORK;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH;
                      uses ADVERTISE-VRF-IMP-DISABLE-V4;
                    }
                  }
                  uses INTERNAL-VPN-CLIENT-IBGPCE;
                  uses LOCAL-ADDRESS;
                  uses BMP-ACTIVATE-TABLE;
                  uses EBGP-MULTIHOP;
                  uses SESSION-GROUP-ADD-MEMBER;
                  uses EGRESS-PEER-ENGINEERING;
                  uses REMOTE-AS;
                  uses LOCAL-AS;
                  uses NEIGHBOR-GRACEFUL-RESTART-STALEPATH-TIME;
                  uses SHUTDOWN;
                  uses DESCRIPTION;
                  uses NEIGHBOR-GROUP-ADD-MEMBER;
                  uses PASSWORD;
                  uses EBGP-RECV-DMZ;
                  uses ADVERTISEMENT-INTERVAL;
                  uses NEIGHBOR-CLUSTER-ID;
                  uses NEIGHBOR-GRACEFUL-RESTART;
                  uses ENFORCE-FIRST-AS;
                  uses IDLE-WATCH-TIME;
                  uses TCPMSS;
                  uses SESSION-OPEN-MODE;
                  uses TOS;
                  uses UPDATE-IN-FILTERING;
                  uses EBGP-SEND-DMZ-ENABLE-MODES;
                  uses MSG-LOG-OUT;
                  uses SUPPRESS-ALL-CAPABILITIES;
                  uses MAX-PEERS;
                  uses RECEIVE-BUFFER-SIZE;
                  uses MSG-LOG-IN;
                  uses ADDITIONAL-PATHS-SEND-CAPABILITY;
                  uses PROPAGATE-DMZ-LINK-BANDWIDTH;
                  uses BFD-ENABLE-MODES;
                  uses SEND-BUFFER-SIZE;
                  uses TTL-SECURITY;
                  uses NEIGHBOR-GRACEFUL-RESTART-TIME;
                  uses TIMERS;
                  uses BFD-MULTIPLIER;
                  uses BFD-MINIMUM-INTERVAL;
                  uses REMOTE-AS-LIST;
                  uses ADDITIONAL-PATHS-RECEIVE-CAPABILITY;
                  uses KEYCHAIN;
                  uses IGNORE-CONNECTED-CHECK-EBGP;
                  uses SUPPRESS-FOUR-BYTE-AS-CAPABILITY;
                  uses UPDATE-SOURCE-INTERFACE;
                  uses GRACEFUL-MAINTENANCE;
                }

                list vrf-neighbor {
                  key "neighbor-address";
                  description "A particular VRF peer";
                  leaf neighbor-address {
                    type inet:ip-address-no-zone;
                    description "Neighbor address";
                  }
                  uses VRF-NEIGHBOR-CONTENT;
                }

                list vrf-neighbor-prefix-length {
                  key "prefix-length neighbor-address";
                  description "A particular VRF peer";
                  leaf prefix-length {
                    type uint32 {
                      range "0..127";
                    }
                    description "Prefix length";
                  }
                  leaf neighbor-address {
                    type inet:ip-address-no-zone;
                    description "Neighbor address";
                  }
                  uses VRF-NEIGHBOR-CONTENT;
                }
                description "BGP VRF peer";
              }
              leaf vrf-name {
                type xr:Cisco-ios-xr-string;
                description "VRF name";
              }
            }
          }

          container default-vrf {
            description "Global default config";

            container bgp-entity {
              description
                "Neighbor, neighbor-group, af-group and
                session-group configuration";

              container neighbors {

                grouping NEIGHBOR-CONTENT {
                  description "NEIGHBOR CONTENT";

                  container neighbor-afs {
                    description
                      "BGP neighbor AF configuration table";

                    list neighbor-af {
                      key "af-name";
                      description "Address family type of neighbor";
                      leaf af-name {
                        type dt1:Bgp-address-family;
                        description "BGP neighbor address family";
                      }
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-CAPABLE";
                      uses L2VPN-SIGNALLING;
                      uses SEND-EXT-COMMUNITY-EBGP;
                      uses ACCEPT-ROUTE-LEGACY-RT;
                      uses AIGP-COST-COMMUNITY;
                      uses SEND-COMMUNITY-EBGP;
                      uses ADVERTISE-DEF-IMP-DISABLE-V6;
                      uses ADVERTISE-DISABLE;
                      uses SEND-MULTICAST-ATTR;
                      uses MAXIMUM-PREFIXES;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH-INBOUND;
                      uses NEXT-HOP-UNCHANGED;
                      uses ADVERTISE-LOCAL-LABELED-ROUTE;
                      uses ADVERTISE-DEF-IMP-DISABLE-V4;
                      uses RPKI-ORIGIN-AS-VALIDATION-DISABLE;
                      uses FLOWSPEC-VALIDATION;
                      uses ADVERTISE-L2VPNEVPN;
                      uses ADVERTISE-LOCAL-L2VPNEVPN;
                      uses ENCAPSULATION-TYPE;
                      uses RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID;
                      uses AS-OVERRIDE;
                      uses MULTIPATH;
                      uses SEND-COMMUNITY-EBGP-GRACEFUL-SHUTDOWN;
                      uses ACTIVATE;
                      uses PREFIX-ORF-POLICY;
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-STALE-TIME";
                      uses AIGP;
                      uses AIGP-SEND-MED;
                      uses ADVERTISE-V6;
                      uses ALLOW-AS-IN;
                      uses ADVERTISE-ORF;
                      uses ROUTE-REFLECTOR-CLIENT;
                      uses NEXT-HOP-SELF;
                      uses ADVERTISE-LOCAL-V6;
                      uses ROUTE-POLICY-IN;
                      uses IMPORT;
                      uses DEFAULT-ORIGINATE;
                      uses SOFT-RECONFIGURATION;
                      uses ADVERTISE-VRF-IMP-DISABLE-V6;
                      uses DEFAULT-WEIGHT;
                      uses AF-GROUP;
                      uses ADVERTISE-V4;
                      uses NEXT-HOP-UNCHANGED-MULTIPATH;
                      uses ACCEPT-OWN;
                      uses ROUTE-POLICY-OUT;
                      uses ADVERTISE-LOCAL-V4;
                      uses ADVERTISE-PERMANENT-NETWORK;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH;
                      uses ADVERTISE-VRF-IMP-DISABLE-V4;
                    }
                  }
                  uses INTERNAL-VPN-CLIENT-IBGPCE;
                  uses LOCAL-ADDRESS;
                  uses BMP-ACTIVATE-TABLE;
                  uses EBGP-MULTIHOP;
                  uses SESSION-GROUP-ADD-MEMBER;
                  uses EGRESS-PEER-ENGINEERING;
                  uses REMOTE-AS;
                  uses LOCAL-AS;
                  uses NEIGHBOR-GRACEFUL-RESTART-STALEPATH-TIME;
                  uses SHUTDOWN;
                  uses DESCRIPTION;
                  uses NEIGHBOR-GROUP-ADD-MEMBER;
                  uses PASSWORD;
                  uses EBGP-RECV-DMZ;
                  uses ADVERTISEMENT-INTERVAL;
                  uses NEIGHBOR-CLUSTER-ID;
                  uses NEIGHBOR-GRACEFUL-RESTART;
                  uses ENFORCE-FIRST-AS;
                  uses IDLE-WATCH-TIME;
                  uses TCPMSS;
                  uses SESSION-OPEN-MODE;
                  uses BGP-CFG-RPKI-ORIGIN-AS-VALIDATION-DISABLE;
                  uses TOS;
                  uses UPDATE-IN-FILTERING;
                  uses EBGP-SEND-DMZ-ENABLE-MODES;
                  uses MSG-LOG-OUT;
                  uses SUPPRESS-ALL-CAPABILITIES;
                  uses MAX-PEERS;
                  uses BGP-CFG-RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID;
                  uses RECEIVE-BUFFER-SIZE;
                  uses MSG-LOG-IN;
                  uses ADDITIONAL-PATHS-SEND-CAPABILITY;
                  uses PROPAGATE-DMZ-LINK-BANDWIDTH;
                  uses BFD-ENABLE-MODES;
                  uses SEND-BUFFER-SIZE;
                  uses TTL-SECURITY;
                  uses NEIGHBOR-GRACEFUL-RESTART-TIME;
                  uses TIMERS;
                  uses BFD-MULTIPLIER;
                  uses BFD-MINIMUM-INTERVAL;
                  uses REMOTE-AS-LIST;
                  uses ADDITIONAL-PATHS-RECEIVE-CAPABILITY;
                  uses KEYCHAIN;
                  uses IGNORE-CONNECTED-CHECK-EBGP;
                  uses SUPPRESS-FOUR-BYTE-AS-CAPABILITY;
                  uses UPDATE-SOURCE-INTERFACE;
                  uses GRACEFUL-MAINTENANCE;
                }

                list neighbor {
                  key "neighbor-address";
                  description "A particular BGP peer";
                  leaf neighbor-address {
                    type inet:ip-address-no-zone;
                    description "Neighbor address";
                  }
                  uses NEIGHBOR-CONTENT;
                }

                list neighbor-prefix-length {
                  key "prefix-length neighbor-address";
                  description "A particular BGP peer";
                  leaf prefix-length {
                    type uint32 {
                      range "0..127";
                    }
                    description "Prefix length";
                  }
                  leaf neighbor-address {
                    type inet:ip-address-no-zone;
                    description "Neighbor address";
                  }
                  uses NEIGHBOR-CONTENT;
                }
                description "Neighbor configuration";
              }

              container neighbor-groups {
                description "Neighbor-group configuration";

                list neighbor-group {
                  key "neighbor-group-name";
                  description "A particular BGP neighbor group";

                  container neighbor-group-afs {
                    description
                      "BGP neighbor-group AF configuration table";

                    list neighbor-group-af {
                      key "af-name";
                      description
                        "Address family type of neighbor group";
                      leaf af-name {
                        type dt1:Bgp-address-family;
                        description
                          "BGP neighbor group address family";
                      }
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-CAPABLE";
                      uses L2VPN-SIGNALLING;
                      uses SEND-EXT-COMMUNITY-EBGP;
                      uses ACCEPT-ROUTE-LEGACY-RT;
                      uses AIGP-COST-COMMUNITY;
                      uses SEND-COMMUNITY-EBGP;
                      uses ADVERTISE-DEF-IMP-DISABLE-V6;
                      uses ADVERTISE-DISABLE;
                      uses SEND-MULTICAST-ATTR;
                      uses MAXIMUM-PREFIXES;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH-INBOUND;
                      uses NEXT-HOP-UNCHANGED;
                      uses ADVERTISE-LOCAL-LABELED-ROUTE;
                      uses ADVERTISE-DEF-IMP-DISABLE-V4;
                      uses RPKI-ORIGIN-AS-VALIDATION-DISABLE;
                      uses FLOWSPEC-VALIDATION;
                      uses ADVERTISE-L2VPNEVPN;
                      uses ADVERTISE-LOCAL-L2VPNEVPN;
                      uses ENCAPSULATION-TYPE;
                      uses RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID;
                      uses AS-OVERRIDE;
                      uses MULTIPATH;
                      uses SEND-COMMUNITY-EBGP-GRACEFUL-SHUTDOWN;
                      uses ACTIVATE;
                      uses PREFIX-ORF-POLICY;
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-STALE-TIME";
                      uses SITE-OF-ORIGIN;
                      uses AIGP;
                      uses AIGP-SEND-MED;
                      uses ADVERTISE-V6;
                      uses ALLOW-AS-IN;
                      uses ADVERTISE-ORF;
                      uses ROUTE-REFLECTOR-CLIENT;
                      uses NEXT-HOP-SELF;
                      uses ADVERTISE-LOCAL-V6;
                      uses ROUTE-POLICY-IN;
                      uses IMPORT;
                      uses DEFAULT-ORIGINATE;
                      uses SOFT-RECONFIGURATION;
                      uses ADVERTISE-VRF-IMP-DISABLE-V6;
                      uses DEFAULT-WEIGHT;
                      uses AF-GROUP;
                      uses ADVERTISE-V4;
                      uses NEXT-HOP-UNCHANGED-MULTIPATH;
                      uses ACCEPT-OWN;
                      uses ROUTE-POLICY-OUT;
                      uses ADVERTISE-LOCAL-V4;
                      uses ADVERTISE-PERMANENT-NETWORK;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH;
                      uses ADVERTISE-VRF-IMP-DISABLE-V4;
                    }
                  }
                  leaf neighbor-group-add-member {
                    type string;
                    description
                      "Inherit configuration from a
                      neighbor-group";
                  }
                  leaf neighbor-group-name {
                    type xr:Cisco-ios-xr-string;
                    description "BGP neighbor group name";
                  }
                  uses INTERNAL-VPN-CLIENT-IBGPCE;
                  uses LOCAL-ADDRESS;
                  uses BMP-ACTIVATE-TABLE;
                  uses EBGP-MULTIHOP;
                  uses SESSION-GROUP-ADD-MEMBER;
                  uses EGRESS-PEER-ENGINEERING;
                  uses REMOTE-AS;
                  uses LOCAL-AS;
                  uses NEIGHBOR-GRACEFUL-RESTART-STALEPATH-TIME;
                  uses SHUTDOWN;
                  uses DESCRIPTION;
                  uses PASSWORD;
                  uses EBGP-RECV-DMZ;
                  uses ADVERTISEMENT-INTERVAL;
                  uses NEIGHBOR-CLUSTER-ID;
                  uses NEIGHBOR-GRACEFUL-RESTART;
                  uses ENFORCE-FIRST-AS;
                  uses IDLE-WATCH-TIME;
                  uses TCPMSS;
                  uses SESSION-OPEN-MODE;
                  uses BGP-CFG-RPKI-ORIGIN-AS-VALIDATION-DISABLE;
                  uses TOS;
                  uses UPDATE-IN-FILTERING;
                  uses EBGP-SEND-DMZ-ENABLE-MODES;
                  uses MSG-LOG-OUT;
                  uses SUPPRESS-ALL-CAPABILITIES;
                  uses MAX-PEERS;
                  uses BGP-CFG-RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID;
                  uses RECEIVE-BUFFER-SIZE;
                  uses MSG-LOG-IN;
                  uses ADDITIONAL-PATHS-SEND-CAPABILITY;
                  uses PROPAGATE-DMZ-LINK-BANDWIDTH;
                  uses BFD-ENABLE-MODES;
                  uses SEND-BUFFER-SIZE;
                  uses TTL-SECURITY;
                  uses NEIGHBOR-GRACEFUL-RESTART-TIME;
                  uses TIMERS;
                  uses BFD-MULTIPLIER;
                  uses BFD-MINIMUM-INTERVAL;
                  uses REMOTE-AS-LIST;
                  uses ADDITIONAL-PATHS-RECEIVE-CAPABILITY;
                  uses KEYCHAIN;
                  uses IGNORE-CONNECTED-CHECK-EBGP;
                  uses SUPPRESS-FOUR-BYTE-AS-CAPABILITY;
                  uses UPDATE-SOURCE-INTERFACE;
                  uses CREATE;
                  uses GRACEFUL-MAINTENANCE;
                }
              }

              container af-groups {
                description "AF-group configuration";

                list af-group {
                  key "af-group-name";
                  description "A particular BGP AF group";

                  container af-group-afs {
                    description "AF group configuration table";

                    list af-group-af {
                      key "af-name";
                      description
                        "Address family type of an AF group";
                      leaf af-group {
                        type string;
                        description
                          "Inherit configuration for this
                          address-family from an AF-group";
                      }
                      leaf create {
                        type empty;
                        description
                          "Create this address family group.
                          Deletion of this object causes deletion
                          of all the objects under AFGroup
                          associated with this object.";
                      }
                      leaf af-name {
                        type dt1:Bgp-address-family;
                        description "BGP AF group address family";
                      }
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-CAPABLE";
                      uses L2VPN-SIGNALLING;
                      uses SEND-EXT-COMMUNITY-EBGP;
                      uses ACCEPT-ROUTE-LEGACY-RT;
                      uses AIGP-COST-COMMUNITY;
                      uses SEND-COMMUNITY-EBGP;
                      uses ADVERTISE-DEF-IMP-DISABLE-V6;
                      uses ADVERTISE-DISABLE;
                      uses SEND-MULTICAST-ATTR;
                      uses MAXIMUM-PREFIXES;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH-INBOUND;
                      uses NEXT-HOP-UNCHANGED;
                      uses ADVERTISE-LOCAL-LABELED-ROUTE;
                      uses ADVERTISE-DEF-IMP-DISABLE-V4;
                      uses RPKI-ORIGIN-AS-VALIDATION-DISABLE;
                      uses FLOWSPEC-VALIDATION;
                      uses ADVERTISE-L2VPNEVPN;
                      uses ADVERTISE-LOCAL-L2VPNEVPN;
                      uses ENCAPSULATION-TYPE;
                      uses RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID;
                      uses AS-OVERRIDE;
                      uses MULTIPATH;
                      uses SEND-COMMUNITY-EBGP-GRACEFUL-SHUTDOWN;
                      uses PREFIX-ORF-POLICY;
                      uses "NEIGHBOR-AF-LONG-LIVED"+
                        "-GRACEFUL-RESTART-STALE-TIME";
                      uses SITE-OF-ORIGIN;
                      uses AIGP;
                      uses AIGP-SEND-MED;
                      uses ADVERTISE-V6;
                      uses ALLOW-AS-IN;
                      uses ADVERTISE-ORF;
                      uses ROUTE-REFLECTOR-CLIENT;
                      uses NEXT-HOP-SELF;
                      uses ADVERTISE-LOCAL-V6;
                      uses ROUTE-POLICY-IN;
                      uses IMPORT;
                      uses DEFAULT-ORIGINATE;
                      uses SOFT-RECONFIGURATION;
                      uses ADVERTISE-VRF-IMP-DISABLE-V6;
                      uses DEFAULT-WEIGHT;
                      uses ADVERTISE-V4;
                      uses NEXT-HOP-UNCHANGED-MULTIPATH;
                      uses ACCEPT-OWN;
                      uses ROUTE-POLICY-OUT;
                      uses ADVERTISE-LOCAL-V4;
                      uses ADVERTISE-PERMANENT-NETWORK;
                      uses REMOVE-PRIVATE-AS-ENTIRE-AS-PATH;
                      uses ADVERTISE-VRF-IMP-DISABLE-V4;
                    }
                  }
                  leaf af-group-name {
                    type xr:Cisco-ios-xr-string;
                    description "BGP AF group name";
                  }
                }
              }

              container session-groups {
                description "Session group configuration";

                list session-group {
                  key "session-group-name";
                  description "A particular BGP session group";
                  leaf session-group-add-member {
                    type string;
                    description
                      "Inherit address-family independent config
                      from a session-group";
                  }
                  leaf session-group-name {
                    type xr:Cisco-ios-xr-string;
                    description "BGP session group name";
                  }
                  uses INTERNAL-VPN-CLIENT-IBGPCE;
                  uses LOCAL-ADDRESS;
                  uses BMP-ACTIVATE-TABLE;
                  uses EBGP-MULTIHOP;
                  uses EGRESS-PEER-ENGINEERING;
                  uses REMOTE-AS;
                  uses LOCAL-AS;
                  uses NEIGHBOR-GRACEFUL-RESTART-STALEPATH-TIME;
                  uses SHUTDOWN;
                  uses DESCRIPTION;
                  uses PASSWORD;
                  uses EBGP-RECV-DMZ;
                  uses ADVERTISEMENT-INTERVAL;
                  uses NEIGHBOR-CLUSTER-ID;
                  uses NEIGHBOR-GRACEFUL-RESTART;
                  uses ENFORCE-FIRST-AS;
                  uses IDLE-WATCH-TIME;
                  uses TCPMSS;
                  uses SESSION-OPEN-MODE;
                  uses BGP-CFG-RPKI-ORIGIN-AS-VALIDATION-DISABLE;
                  uses TOS;
                  uses UPDATE-IN-FILTERING;
                  uses EBGP-SEND-DMZ-ENABLE-MODES;
                  uses MSG-LOG-OUT;
                  uses SUPPRESS-ALL-CAPABILITIES;
                  uses MAX-PEERS;
                  uses BGP-CFG-RPKI-BESTPATH-ORIGIN-AS-ALLOW-INVALID;
                  uses RECEIVE-BUFFER-SIZE;
                  uses MSG-LOG-IN;
                  uses ADDITIONAL-PATHS-SEND-CAPABILITY;
                  uses PROPAGATE-DMZ-LINK-BANDWIDTH;
                  uses BFD-ENABLE-MODES;
                  uses SEND-BUFFER-SIZE;
                  uses TTL-SECURITY;
                  uses NEIGHBOR-GRACEFUL-RESTART-TIME;
                  uses TIMERS;
                  uses BFD-MULTIPLIER;
                  uses BFD-MINIMUM-INTERVAL;
                  uses REMOTE-AS-LIST;
                  uses ADDITIONAL-PATHS-RECEIVE-CAPABILITY;
                  uses KEYCHAIN;
                  uses IGNORE-CONNECTED-CHECK-EBGP;
                  uses SUPPRESS-FOUR-BYTE-AS-CAPABILITY;
                  uses UPDATE-SOURCE-INTERFACE;
                  uses CREATE;
                  uses GRACEFUL-MAINTENANCE;
                }
              }
            }

            container global {
              description "Global default config";

              container cluster-id {
                description "Configure Route-Reflector Cluster-id";
                leaf cluster-id-number {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description
                    "Route-Reflector Cluster ID as 32 bit
                    quantity";
                }
                leaf cluster-id-address {
                  type inet:ipv4-address-no-zone;
                  description
                    "Route-Reflector Cluster ID in IPV4 address
                    format";
                }
              }

              container write-limit {
                description
                  "Set write-queue limit for each update group";
                leaf formatted-messages {
                  type uint32 {
                    range "500..100000000";
                  }
                  default "50000";
                  description
                    "Number of messages to be formatted per
                    update group";
                }
                leaf enqueued-messages {
                  type uint32 {
                    range "500..100000000";
                  }
                  default "250000";
                  description
                    "Number of messages that can be enqueued in
                    total";
                }
                leaf desynchronize {
                  type boolean;
                  default "false";
                  description
                    "TRUE to enable desynchronization, FALSE
                    otherwise.";
                }
              }

              container update-delay {
                description
                  "Set the max initial delay for sending
                  updates";
                leaf delay {
                  type uint32 {
                    range "0..3600";
                  }
                  units "second";
                  default "120";
                  description "Delay value (seconds)";
                }
                leaf always {
                  type boolean;
                  default "false";
                  description
                    "Set to TRUE to disable keepalive trigger
                    bestpath and delay is enforced.";
                }
              }

              container as-league {
                description "AS League";

                container peers {
                  description "AS League Peers";

                  list peer {
                    key "as-xx as-yy";
                    description "AS League Peer AS";
                    leaf as-xx {
                      type dt1:Bgp-as-range;
                      description "xx of peer AS xx.yy";
                    }
                    leaf as-yy {
                      type dt1:Bgp-as-range;
                      description "yy of peer AS xx.yy";
                    }
                  }
                }
                leaf enable {
                  type empty;
                  description "AS League creation";
                }
              }

              container rpki-servers {
                description "RPKI server configuration";

                list rpki-server {
                  key "server";
                  description "RPKI server configuration";

                  container transport {
                    description "RPKI server transport";
                    leaf transport {
                      type Bgp-rpki-transport;
                      default "ssh";
                      description "RPKI server transport";
                    }
                    leaf port {
                      type xr:Cisco-ios-xr-port-number;
                      default "22";
                      description "port";
                    }
                  }
                  leaf enable {
                    type empty;
                    description "RPKI server configuration";
                  }
                  leaf shutdown {
                    type empty;
                    description "RPKI server shutdown";
                  }
                  leaf password {
                    type string;
                    description "RPKI server password";
                  }
                  leaf response-time {
                    type int32;
                    units "second";
                    description
                      "RPKI server response-time (seconds)";
                  }
                  leaf username {
                    type string;
                    description "RPKI server username";
                  }
                  leaf refresh-time {
                    type int32;
                    units "second";
                    description
                      "RPKI server refresh-time (seconds)";
                  }
                  leaf purge-time {
                    type int32;
                    units "second";
                    description "RPKI server purge-time (seconds)";
                  }
                  leaf server {
                    type string;
                    description "Server address (opaque string)";
                  }
                }
              }

              container as-list-groups {
                description "AS-list group lists";

                list as-list-group {
                  key "as-list-group-name";
                  description "AS-List group";

                  container ases {
                    description "AS list";

                    list as {
                      key "as-xx as-yy";
                      description "AS-List group";
                      leaf as-xx {
                        type dt1:Bgp-as-range;
                        description
                          "xx of AS number/confed peer xx.yy";
                      }
                      leaf as-yy {
                        type dt1:Bgp-as-range;
                        description
                          "yy of AS number/confed peer xx.yy";
                      }
                    }
                  }
                  leaf enable {
                    type empty;
                    description "AS-List group creation";
                  }
                  leaf as-list-group-name {
                    type xr:Cisco-ios-xr-string;
                    description "Group name";
                  }
                }
              }

              container limits {
                description "Maximum number that can be configured";
                leaf maximum-neighbors {
                  type uint32 {
                    range "1..15000";
                  }
                  default "10000";
                  description
                    "Maximum number of neighbors that can be
                    configured";
                }
              }

              container confederation-domain {
                description "Set routing domain confederation AS";
                leaf as-xx {
                  type dt1:Bgp-as-range;
                  description "xx of AS number xx.yy";
                }
                leaf as-yy {
                  type dt1:Bgp-as-range;
                  description "yy of AS number xx.yy";
                }
              }

              container confederation-peer-ases {
                description "Define peer ASes in BGP confederation";

                list confederation-peer-as {
                  key "as-xx as-yy";
                  description "Confederation peer AS";
                  leaf as-xx {
                    type dt1:Bgp-as-range;
                    description "xx of AS number/confed peer xx.yy";
                  }
                  leaf as-yy {
                    type dt1:Bgp-as-range;
                    description "yy of AS number/confed peer xx.yy";
                  }
                }
              }

              container attribute-filter-groups {
                description "Attribute-filter groups list";

                list attribute-filter-group {
                  key "attribute-filter-group-name";
                  description "Attribute-filter group";

                  container attribute-filters {
                    description
                      "Attribute-filter group attributes list";

                    list attribute-filter {
                      key "attribute-start attribute-end";
                      description
                        "Attribute-filter group attribute";
                      leaf attribute-start {
                        type dt1:Bgp-attribute-range;
                        description "Start of attribute range";
                      }
                      leaf attribute-end {
                        type dt1:Bgp-attribute-range;
                        description "End of attribute range";
                      }
                      leaf filter-action {
                        type dt1:Bgp-update-filter-action;
                        mandatory true;
                        description "Filtering action";
                      }
                    }
                  }
                  leaf enable {
                    type empty;
                    description "Attribute-filter group creation";
                  }
                  leaf attribute-filter-group-name {
                    type xr:Cisco-ios-xr-string;
                    description "Group name";
                  }
                }
              }

              container global-graceful-maintenance-activate {
                description
                  "Activate Graceful Maintenance Mode for all
                  neighbors with graceful maintenance config";
                leaf all-neighbors {
                  type boolean;
                  description
                    "Also for neighbors without graceful
                    maintenance config";
                }
                leaf retain-routes {
                  type boolean;
                  description "Keep routes in RIB once BGP stops";
                }
              }

              container global-afs {
                description "Global AF-specific configuration";

                list global-af {
                  key "af-name";
                  description "Global AF-specific configuration";

                  container isis-routes {
                    description
                      "Redistribute information for IS-IS routes
                      .";

                    list isis-route {
                      key "instance-name";
                      description "Redistribute IS-IS routes";
                      leaf instance-name {
                        type xr:Cisco-ios-xr-string;
                        description "IS-IS instance name";
                      }
                      leaf default-metric {
                        type Bgp-default-metric-range;
                        description "Default metric";
                      }
                      leaf route-policy-name {
                        type string;
                        description "Route policy name";
                      }
                      leaf redist-type {
                        type xr:Hex-integer;
                        description
                          "Redistribution type: 01 for level 1
                          routes, 02 for level 2 routes, 04 for
                          level 1 inter-area routes. Logical
                          combinations permitted.";
                      }
                    }
                  }

                  container domain-distinguisher {
                    presence "Indicates a domain-distinguisher node"+
                      " is configured.";
                    description
                      "<ASN, router-id> tuple to use to identify
                      the link-state domain";
                    leaf as {
                      type dt1:Bgp-as-range;
                      mandatory true;
                      description "AS Number";
                    }
                    leaf router-id {
                      type inet:ipv4-address-no-zone;
                      mandatory true;
                      description "Router ID";
                    }
                  }

                  container vrf-all {
                    description
                      "Configurations to be inherited to all
                      vrfs";

                    container label-mode {
                      description "MPLS-VPN label allocation mode";
                      leaf label-allocation-mode {
                        type string;
                        description
                          "Label allocation mode: per-ce  Set per
                          CE label mode, per-vrf Set per VRF
                          label mode";
                      }
                      leaf route-policy-name {
                        type string;
                        description "Label mode route policy name";
                      }
                    }
                    leaf rnh-install-format {
                      type Bgp-rnh-install-format;
                      description
                        "RNH install format type: extcomm -
                        install rnh as opaque and extcomms,
                        extcomm-only - install rnh as extcomms
                        only";
                    }
                    leaf enable {
                      type empty;
                      description
                        "Enable vrf all configuration submode";
                    }
                    leaf table-policy {
                      type string;
                      description
                        "Configure policy for installation of
                        routes to RIB";
                    }
                    leaf source-rt-import-policy {
                      type empty;
                      description
                        "Enable sourcing of import route-targets 
                        from import-policy";
                    }
                  }

                  container disable-cluster-client-to-client-rrs {
                    description
                      "Disable client-to-client reflection for a
                      cluster";

                    list disable-cluster-client-to-client-rr {
                      must "number or ipv4-address" {
                        description
                          "Number or IPV4Address must be present.";
                      }
                      key "cluster-type";
                      description
                        "Cluster ID for which reflection is to be
                        disbled";
                      leaf cluster-type {
                        type Bgp-cluster-id;
                        description "Type of cluster-id";
                      }

                      list number {
                        when "../cluster-type = 'number'" {
                          description "../ClusterType = Number";
                        }
                        key "cluster-id-number";
                        description "number";
                        leaf cluster-id-number {
                          type uint32 {
                            range "0..4294967295";
                          }
                          description
                            "Cluster ID: if configured as a number";
                        }
                      }

                      list ipv4-address {
                        when "../cluster-type = 'ipv4-address'" {
                          description
                            "../ClusterType = IPV4Address";
                        }
                        key "cluster-id-address";
                        description "ipv4 address";
                        leaf cluster-id-address {
                          type inet:ip-address-no-zone;
                          description
                            "Cluster ID: if configured as an IP
                            Address";
                        }
                      }
                    }
                  }

                  container label-delay {
                    presence "Indicates a label-delay node is"+
                      " configured.";
                    description
                      "Delay timer to batch label processing.";
                    leaf seconds {
                      type uint32 {
                        range "0..10";
                      }
                      units "second";
                      mandatory true;
                      description "Delay, seconds part";
                    }
                    leaf milliseconds {
                      type uint32 {
                        range "0..999";
                      }
                      units "millisecond";
                      mandatory true;
                      description "Delay, milliseconds part";
                    }
                  }

                  container ebgp {
                    presence "Indicates a ebgp node is configured.";
                    description "Use eBGP multipaths";
                    leaf paths-value {
                      type uint32 {
                        range "2..64";
                      }
                      mandatory true;
                      description "Number of paths";
                    }
                    leaf unequal-cost {
                      type boolean;
                      default "false";
                      description "UNUSED";
                    }
                    leaf selective {
                      type boolean;
                      default "false";
                      description
                        "Allow multipaths only from marked
                        neighbors";
                    }
                    leaf order-by-igp-metric {
                      type boolean;
                      default "false";
                      description
                        "Order candidate multipaths by IGP metric";
                    }
                  }

                  container eibgp {
                    presence "Indicates a eibgp node is configured.";
                    description "Use eiBGP multipaths";
                    leaf paths-value {
                      type uint32 {
                        range "2..64";
                      }
                      mandatory true;
                      description "Number of paths";
                    }
                    leaf unequal-cost {
                      type boolean;
                      default "false";
                      description "UNUSED";
                    }
                    leaf selective {
                      type boolean;
                      default "false";
                      description
                        "Allow multipaths only from marked
                        neighbors";
                    }
                    leaf order-by-igp-metric {
                      type boolean;
                      default "false";
                      description
                        "Order candidate multipaths by IGP metric";
                    }
                  }

                  container retain-rt {
                    description
                      "Accept received updates with the
                      specified attributes";
                    leaf all {
                      type boolean;
                      description
                        "Whether all RTs are to be retained,
                        default is FALSE";
                    }
                    leaf route-policy-name {
                      type string;
                      description "Route policy name";
                    }
                  }

                  container ibgp {
                    presence "Indicates a ibgp node is configured.";
                    description "Use iBGP multipaths";
                    leaf paths-value {
                      type uint32 {
                        range "2..64";
                      }
                      mandatory true;
                      description "Number of paths";
                    }
                    leaf unequal-cost {
                      type boolean;
                      default "false";
                      description
                        "Allow multipaths to have different IGP
                        metrics";
                    }
                    leaf selective {
                      type boolean;
                      default "false";
                      description
                        "Allow multipaths only from marked
                        neighbors";
                    }
                    leaf order-by-igp-metric {
                      type boolean;
                      default "false";
                      description
                        "Order candidate multipaths by IGP metric";
                    }
                  }

                  container import-delay {
                    presence "Indicates a import-delay node is"+
                      " configured.";
                    description
                      "Delay timer to batch import processing.";
                    leaf seconds {
                      type uint32 {
                        range "0..10";
                      }
                      units "second";
                      mandatory true;
                      description "Delay, seconds part";
                    }
                    leaf milliseconds {
                      type uint32 {
                        range "0..999";
                      }
                      units "millisecond";
                      mandatory true;
                      description "Delay, milliseconds part";
                    }
                  }
                  leaf rnh-install-format {
                    type Bgp-rnh-install-format;
                    description
                      "RNH install format type: extcomm -
                      install rnh as opaque and extcomms,
                      extcomm-only - install rnh as extcomms
                      only";
                  }
                  leaf inter-as-install {
                    type empty;
                    description
                      "Enable install remote MVPN routes to PIM
                      in default VRF";
                  }
                  leaf segmented-mcast {
                    type empty;
                    description "Enable segmented multicast";
                  }
                  leaf disable-default-martian-check {
                    type empty;
                    description "Disable default Martian Check";
                  }
                  leaf next-hop-critical-trigger-delay {
                    type uint32 {
                      range "0..4294967295";
                    }
                    units "millisecond";
                    default "3000";
                    description "Next hop Critical Trigger Delay";
                  }
                  leaf next-hop-non-critical-trigger-delay {
                    type uint32 {
                      range "0..4294967295";
                    }
                    units "millisecond";
                    default "10000";
                    description
                      "Next hop Non-critical Trigger Delay";
                  }
                  leaf label-security-rpf {
                    type empty;
                    description
                      "Calculate label-security RPF lists and
                      install to RIB/LSD";
                  }
                  leaf use-igpsr-label {
                    type empty;
                    description
                      "Use IGP SR label for resolution
                      configuration";
                  }
                  leaf label-retain {
                    type uint32 {
                      range "3..60";
                    }
                    units "minute";
                    description "Label retention time in minutes";
                  }
                  leaf scan-time {
                    type uint32 {
                      range "5..3600";
                    }
                    units "second";
                    default "60";
                    description
                      "Configure background scanner interval for
                      this address family";
                  }
                  leaf rpki-origin-as-validation-disable {
                    type empty;
                    description "RPKI origin-AS validation disable";
                  }
                  leaf rpki-origin-as-validity-signal-ibgp {
                    type empty;
                    description
                      "RPKI origin-AS validity signal ibgp";
                  }
                  leaf update-limit-sub-group-ebgp {
                    type uint32 {
                      range "1..512";
                    }
                    units "megabyte";
                    default "32";
                    description
                      "Upper bound on update generation
                      transient memory usage for every EBGP
                      Sub-group";
                  }
                  leaf update-limit-address-family {
                    type uint32 {
                      range "4..2048";
                    }
                    units "megabyte";
                    default "256";
                    description
                      "Upper bound on update generation
                      transient memory usage for the
                      address-family";
                  }
                  leaf rpki-bestpath-use-origin-as-validity {
                    type empty;
                    description
                      "RPKI bestpath use origin-AS validity";
                  }
                  leaf update-limit-sub-group-ibgp {
                    type uint32 {
                      range "1..512";
                    }
                    units "megabyte";
                    default "32";
                    description
                      "Upper bound on update generation
                      transient memory usage for every IBGP
                      Sub-group";
                  }
                  leaf rpki-bestpath-origin-as-allow-invalid {
                    type empty;
                    description
                      "RPKI bestpath origin-AS allow invalid";
                  }
                  leaf disable-client-to-client-rr {
                    type empty;
                    description
                      "Disable client-to-client reflection";
                  }
                  leaf next-hop-route-policy {
                    type string;
                    description
                      "Next hop policy to filter out nexthop
                      notification";
                  }
                  leaf global-table-mcast {
                    type empty;
                    description "Enable global table multicast";
                  }
                  leaf wait-rib-install {
                    type empty;
                    description
                      "Wait for route install before sending
                      updates to neighbors";
                  }
                  leaf af-name {
                    type dt1:Bgp-address-family;
                    description "Address family";
                  }
                  uses AGGREGATE-ADDRESS-TABLE;
                  uses DYNAMIC-MED-INTERVAL;
                  uses DAMPENING;
                  uses ENABLE;
                  uses RIP-ROUTES;
                  uses LISP-ROUTES;
                  uses STATIC-ROUTES;
                  uses DISTANCE;
                  uses TABLE-POLICY;
                  uses APP-ROUTE-TABLE;
                  uses ATTRIBUTE-DOWNLOAD;
                  uses LABEL-MODE;
                  uses EIGRP-ROUTE-TABLE;
                  uses BEST-EXTERNAL;
                  uses SOURCED-NETWORK-TABLE;
                  uses CONNECTED-ROUTES;
                  uses ADDITIONAL-PATHS-RECEIVE;
                  uses PERMANENT-NETWORK;
                  uses ALLOCATE-LABEL;
                  uses ADDITIONAL-PATHS-SELECTION;
                  uses NEXT-HOP-RESOLUTION-PREFIX-LENGTH-MINIMUM;
                  uses RESET-WEIGHT-ON-IMPORT;
                  uses OSPF-ROUTE-TABLE;
                  uses ADDITIONAL-PATHS-SEND;
                  uses ADVERTISE-LOCAL-LABELED-ROUTE-SAFI-UNICAST;
                  uses MOBILE-ROUTES;
                  uses DISABLE-AS-PATH-LOOP-CHECK;
                  uses SUBSCRIBER-ROUTES;
                }
              }

              container rpki-static-routes {
                description "RPKI static route configuration";

                list rpki-static-route {
                  key "addrress minimum maximum as";
                  description "RPKI static route";
                  leaf addrress {
                    type inet:ip-address-no-zone;
                    description "Address";
                  }
                  leaf minimum {
                    type int32;
                    description "Minimum Prefix Length";
                  }
                  leaf maximum {
                    type int32;
                    description "Maximum Prefix Length";
                  }
                  leaf as {
                    type int32;
                    description "AS Number";
                  }
                }
              }
              leaf graceful-restart {
                type empty;
                description "Enable graceful restart support";
              }
              leaf update-out-logging {
                type empty;
                description
                  "Enables logging of update generation events";
              }
              leaf install-diversion {
                type empty;
                description "Install diversion path to RIB/CEF";
              }
              leaf next-hop-trigger-delay {
                type uint32 {
                  range "0..300";
                }
                units "second";
                default "5";
                description
                  "Set the delay for triggering nexthop
                  recalculations";
              }
              leaf nsr {
                type boolean;
                description
                  "TRUE to Enable non-stop routing
                  supportFALSE to Disable non-stop routing
                  support";
              }
              leaf neighbor-logging-detail {
                type empty;
                description
                  "Include extra detail in neighbor change
                  messages";
              }
              leaf mvpn {
                type empty;
                description "Connect to PIM/PIM6";
              }
              leaf rpki-origin-as-validation-disable {
                type empty;
                description "RPKI origin-AS validation disable";
              }
              leaf rpki-origin-as-validity-signal-ibgp {
                type empty;
                description "RPKI origin-AS validity signal ibgp";
              }
              leaf global-scan-time {
                type uint32 {
                  range "5..3600";
                }
                units "second";
                default "60";
                description
                  "Configure background scanner interval for
                  generic scanner";
              }
              leaf rpki-bestpath-use-origin-as-validity {
                type empty;
                description "RPKI bestpath use origin-AS validity";
              }
              leaf rpki-origin-as-validation-time {
                type uint32 {
                  range "0..60";
                }
                units "second";
                description
                  "Prefix validation time (in seconds). Range 
                  : 5 - 60. Specify 0 to disable the timer";
              }
              leaf rpki-bestpath-origin-as-allow-invalid {
                type empty;
                description "RPKI bestpath origin-AS allow invalid";
              }
              leaf graceful-restart-purge-time {
                type uint32 {
                  range "1..6000";
                }
                units "second";
                default "600";
                description "Time before stale routes are purged.";
              }
              leaf enforce-ibgp-out-policy {
                type empty;
                description
                  "Allow all attributes to be modified by
                  outbound policy for iBGP peers";
              }
              leaf update-limit-process {
                type uint32 {
                  range "16..2048";
                }
                units "megabyte";
                default "512";
                description
                  "Upper bound on update generation transient
                  memory usage for the process";
              }
              leaf graceful-restart-time {
                type uint32 {
                  range "1..4095";
                }
                units "second";
                default "120";
                description "Restart time advertised to neighbors";
              }
              leaf update-error-handling-basic-ibgp-disable {
                type empty;
                description
                  "Inbound update basic error-handling for
                  IBGP neighbors";
              }
              leaf read-only {
                type empty;
                description
                  "Allow duplicate table config and disable
                  update generation";
              }
              leaf graceful-restart-stalepath-time {
                type uint32 {
                  range "1..4095";
                }
                units "second";
                default "360";
                description
                  "Maximum time to wait for restart of GR
                  capable peers";
              }
              leaf update-error-handling-extended-ebgp {
                type empty;
                description
                  "Inbound update extended error-handling for
                  EBGP neighbors";
              }
              leaf update-error-handling-basic-ebgp-disable {
                type empty;
                description
                  "Inbound update basic error-handling for
                  EBGP neighbors";
              }
              leaf graceful-reset {
                type empty;
                description
                  "Reset gracefully if configuration change
                  forces a peer reset";
              }
              leaf igp-loop-check {
                type empty;
                description
                  "Enable AS-path loop checking for iBGP peers";
              }
              leaf update-error-handling-extended-ibgp {
                type empty;
                description
                  "Inbound update extended error-handling for
                  IBGP neighbors";
              }
              uses ROUTER-ID;
              uses DISABLE-ENFORCE-FIRST-AS;
              uses BEST-PATH-COST-COMMUNITY;
              uses BEST-PATH-AIGP-IGNORE;
              uses BEST-PATH-AS-PATH-LENGTH;
              uses IGP-REDIST-INTERNAL;
              uses MULTI-PATH-AS-PATH-IGNORE-ONWARDS;
              uses DISABLE-FAST-EXTERNAL-FALLOVER;
              uses DEFAULT-METRIC;
              uses DEFAULT-INFO-ORIGINATE;
              uses BEST-PATH-CONFEDERATION-PATHS;
              uses BEST-PATH-AS-MULTIPATH-RELAX;
              uses MPLS-ACTIVATED-INTERFACE-TABLE;
              uses DISABLE-AUTO-SOFT-RESET;
              uses DISABLE-MSG-LOG;
              uses GLOBAL-TIMERS;
              uses BFD;
              uses DISABLE-NEIGHBOR-LOGGING;
              uses SEND-SOCKET-BUFFER-SIZES;
              uses BEST-PATH-MED-ALWAYS;
              uses RECEIVE-SOCKET-BUFFER-SIZES;
              uses BEST-PATH-ROUTER-ID;
              uses BEST-PATH-MED-MISSING;
              uses LOCAL-PREFERENCE;
            }
          }
          leaf bgp-running {
            type empty;
            description
              "Enable BGP. Deletion of this object causes
              deletion of all the objects under FourByteAS
              associated with this object.";
          }
          leaf as {
            type dt1:Bgp-as-range;
            description "2-byte or 4-byte Autonomous system number";
          }
        }
      }
    }
  }

  container bmp-server-all {
    description "bmp server all";

    container route-monitoring {
      description
        "Enable Route Monitoring capability for the BMP
        servers.\nBGP update messages messages will be
        regenrated with a table walk\n";
      leaf policy {
        type Bmp-policy-select;
        description
          "Specify if the routes packed in update messages
          should be\nbefore or after the application of
          route-policy";
      }
      leaf direction {
        type Bmp-route-direction;
        description
          "Specify if the routes should be picked up at
          inbound\nor outbound direction";
      }
    }
    leaf maximum-buffer-size {
      type uint32 {
        range "1..4294967295";
      }
      units "megabyte";
      description
        "Range in MegaBytes for the maximum buffer size
        of BMP message queue.\nThe maximum buf-size is
        20% and default buf-size is 15% of the
        platform\nvirtual memory max-limit (aka rlimit).
        Please run show bgp process
        performance-statistics\nto see the individual
        values. Unit is in Megabytes";
    }
  }

  container bmp-servers {
    description "bmp servers";

    list bmp-server {
      key "server-id";
      description "A particular BMP server";

      container initial-refresh-delay {
        description "Initial refresh to generate BGP updates";
        leaf delay {
          type uint32 {
            range "0..3600";
          }
          units "second";
          description
            "Delay in seconds before sending Refresh
            request to Peers";
        }
        leaf spread {
          type uint32 {
            range "0..3600";
          }
          description
            "Spread over which to send initial Refresh
            request to Peers";
        }
      }

      container host-port {
        description
          "Configure Host Name/Address and Port for BMP
          Server";
        leaf host {
          type string;
          description
            "Name of the BMP server(accepts IPv4/IPv6
            Address format too)";
        }
        leaf port {
          type xr:Cisco-ios-xr-port-number;
          description "Port Number of listening BMP server";
        }
      }

      container tos {
        description "TOS (Type Of Service)";
        leaf type {
          type dt1:Bgp-tos;
          description "Set type of service";
        }
        leaf value {
          type dt1:Bgp-precedence-dscp;
          description "TOS value to set";
        }
      }
      leaf create {
        type empty;
        description "BMP Server Creation";
      }
      leaf maximum-buffer-size {
        type uint32 {
          range "1..4294967295";
        }
        units "megabyte";
        description
          "Range in MegaBytes for the maximum buffer size
          of BMP message queue.\nThe maximum buf-size is
          20% and default buf-size is 15% of the
          platform\nvirtual memory max-limit (aka rlimit)
          . Please run show bgp process
          performance-statistics\nto see the individual
          values. Unit is in Megabytes";
      }
      leaf initial-delay {
        type uint32 {
          range "1..3600";
        }
        units "second";
        description
          "Initial connect delay in seconds in sending
          updates";
      }
      leaf flapping-delay {
        type uint32 {
          range "60..3600";
        }
        units "second";
        description
          "Delay in connecting to BMP Server after a flap
          had been detected.";
      }
      leaf status-report-interval {
        type uint32 {
          range "1..3600";
        }
        units "second";
        description "Stats reporting period for BMP server";
      }
      leaf description {
        type string;
        description "String to describe the BMP server";
      }
      leaf bmptcp-maximum-segment-size {
        type uint32 {
          range "68..10000";
        }
        units "byte";
        description
          "configure TCP maximum segment size.
          Default=16384.";
      }
      leaf bmptcp-keep-alive {
        type uint32 {
          range "0..7200";
        }
        units "second";
        description
          "configure TCP keep alives to be exchanged
          between client and server. Default=1000";
      }
      leaf vrf {
        type string;
        description "VRF for BMP Server";
      }
      leaf shutdown {
        type boolean;
        description
          "TRUE to shutdown the BMP Server ConnectionFALSE
          to bring back the BMP Server Connection";
      }
      leaf update-source-interface {
        type xr:Interface-name;
        description "Select an interface to configure";
      }
      leaf server-id {
        type uint32 {
          range "1..8";
        }
        description "BMP Server ID";
      }
    }
  }

  augment "/a2:snmp/a2:notification" {

    container bgp {
      description
        "BGP4-MIB and CISCO-BGP4-MIB notification
        configuration";

      container bgp4mib {
        description
          "Enable BGP4-MIB and CISCO-BGP4-MIB IPv4-only
          notifications: bgpEstablishedNotification,
          bgpBackwardTransNotification,
          cbgpFsmStateChange, cbgpBackwardTransition,
          cbgpPrefixThresholdExceeded,
          cbgpPrefixThresholdClear.";
        leaf enable {
          type empty;
          description
            "Enable BGP4-MIB and CISCO-BGP4-MIB IPv4-only
            notifications";
        }
        leaf up-down {
          type empty;
          description
            "Enable BGP4-MIB and CISCO-BGP4-MIB IPv4-only
            up/down notifications";
        }
      }

      container cisco-bgp4mib {
        description
          "Enable CISCO-BGP4-MIB v2 notifications:
          cbgpPeer2EstablishedNotification,
          cbgpPeer2BackwardTransNotification,
          cbgpPeer2FsmStateChange,
          cbgpPeer2BackwardTransition,
          cbgpPeer2PrefixThresholdExceeded,
          cbgpPeer2PrefixThresholdClear.";
        leaf enable {
          type empty;
          description "Enable CISCO-BGP4-MIB v2 notifications";
        }
        leaf up-down {
          type empty;
          description
            "Enable CISCO-BGP4-MIB v2 up/down notifications";
        }
      }
    }
    description
      "This augment extends the configuration data of
      'Cisco-IOS-XR-snmp-agent-cfg'";
  }

  augment "/a1:vrfs/a1:vrf/a1:afs/a1:af" {

    container bgp {
      description "BGP AF VRF config";

      container import-route-targets {
        description "Import Route targets";
        uses ROUTE-TARGET-TABLE;
      }

      container export-route-targets {
        description "Export Route targets";
        uses ROUTE-TARGET-TABLE;
      }

      container vrf-to-global-export-route-policy {
        presence "Indicates a vrf-to-global-export-route-policy"+
          " node is configured.";
        description
          "Route policy for vrf to global export filtering";
        leaf route-policy-name {
          type string;
          mandatory true;
          description "Vrf to global export route policy";
        }
        leaf allow-imported-vpn {
          type boolean;
          description
            "TRUE Enable imported VPN paths to be exported
            to Default VRF.FALSE Disable imported VPN
            paths to be exported to Default VRF.";
        }
      }

      container export-vrf-options {
        description "Export VRF options";
        leaf allow-imported-vpn {
          type boolean;
          description
            "TRUE Enable imported VPN paths to be exported
            to non-default VRFFALSE Disable imported VPN
            paths to be exported to non-default VRF";
        }
        leaf import-stitching-rt {
          type boolean;
          description
            "TRUE Use stitchng RTs to import extranet
            pathsFALSE Use regular RTs to import extranet
            paths";
        }
      }

      container global-to-vrf-import-route-policy {
        presence "Indicates a global-to-vrf-import-route-policy"+
          " node is configured.";
        description
          "Route policy for global to vrf import filtering";
        leaf route-policy-name {
          type string;
          mandatory true;
          description "Global to vrf import route policy";
        }
        leaf advertise-as-vpn {
          type boolean;
          description
            "TRUE Enable advertising imported paths to
            PEsFALSE Disable advertising imported paths to
            PEs";
        }
      }
      leaf export-route-policy {
        type string;
        description "Route policy for export filtering";
      }
      leaf import-route-policy {
        type string;
        description "Route policy for import filtering";
      }
      leaf import-vrf-options {
        type boolean;
        description
          "TRUE Enable advertising imported paths to
          PEsFALSE Disable advertising imported paths to
          PEs";
      }
    }
    description
      "This augment extends the configuration data of
      'Cisco-IOS-XR-infra-rsi-cfg'";
  }
}