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

    yang-version 1;

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

    prefix ipv4-bgp-cfg;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }
    import Cisco-IOS-XR-ipv4-bgp-datatypes {
      prefix dt1;
    }
    import Cisco-IOS-XR-infra-rsi-cfg {
      prefix a1;
    }
    import Cisco-IOS-XR-snmp-agent-cfg {
      prefix a2;
    }

    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 model is deprecated and is replaced by
     Cisco-IOS-XR-um-router-bgp-cfg.yang which will provide the
     compatible functionalities.
     
     This module contains definitions
     for the following management objects:
       asn-format: Autonomous system number format
       bgp: BGP configuration commands
       bmp-server-all: BGP BMP Server Common Configuration
       bmp-servers: BGP BMP Server Configuration
     
     This YANG module augments the
       Cisco-IOS-XR-infra-rsi-cfg,
       Cisco-IOS-XR-snmp-agent-cfg
     modules with configuration data.
     
     Copyright (c) 2013-2021 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2021-03-05" {
      description
        "Deprecated Hidden commands
       2021-03-05
         Added SR Policy Path Prefernce CLI
       2021-02-07
         Add config to include cluster-list-length in multipath criteria
       2020-12-07
         cli/default behavior change for Soft NextHop Validation and Metric
       2020-12-01
         Added best-external advertise config limited to labeled-unicast
       2020-10-27
         BGP change dual-mode configure cli
       2020-10-09
         Changed RPKI password type to Proprietary
       2020-10-04
         Added Soft NextHop Validation and Metric
       2020-07-21
         BGP MIB cfg model has been updated to allow only one of updown or enable options";
    }

    revision "2020-06-16" {
      description
        "Fixing various spellings/typos in descriptions
       2020-05-13
       Support large values for BGP RPKI purge timeout.
       2020-01-29
       Enhancement for OC BFD augmentation in OC BGP.
       2019-10-31
       Added mandatory nodes and presence containers.";
    }

    revision "2019-08-31" {
      description
        "Fixing revision error in module.
       2019-05-12
       Deprecated the native model, replaced by UM model.";
    }

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

    revision "2018-06-15" {
      description
        "Allow min..max in range when min == max.";
    }

    revision "2018-01-18" {
      description
        "Added AO option for neighbor";
    }

    revision "2017-11-05" {
      description
        "Corrected boolean values in when statements.";
    }

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

    revision "2017-07-31" {
      description
        "Fixed missing augmentation from multiple MDA parent.";
    }

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

    revision "2017-06-01" {
      description
        "Revision description string.";
    }

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

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

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

    typedef Bgp-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 Bgp-nbrgr {
      type enumeration {
        enum "true" {
          value 0;
          description
            "NBR has enabled Graceful Restart capability";
        }
        enum "false" {
          value 1;
          description
            "NBR has disabled Graceful Restart capability";
        }
      }
      description "Bgp nbrgr";
    }

    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-rpki-binssrc {
      type enumeration {
        enum "interface" {
          value 0;
          description
            "Bind Source Interface";
        }
      }
      description "Bgp rpki binssrc";
    }

    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-rpki-time-config {
      type union {
        type enumeration {
          enum "off" {
            value 0;
            description "Turn off knob";
          }
        }
        type uint32 {
          range "0..3600";
        }
      }
      description "Bgp rpki time config";
    }

    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 Bgp-upd-dynamic {
      type enumeration {
        enum "bgp-dynamic-split-enable" {
          value 0;
          description "Enable splitting";
        }
        enum "bgp-dynamic-split-disable" {
          value 1;
          description "Disable splitting";
        }
        enum "bgp-dynamic-split-permanent" {
          value 2;
          description "Permanent splitting";
        }
      }
      description "Bgp upd dynamic";
    }

    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 Bgp-orrafi {
      type enumeration {
        enum "bgp-ipv6orr" {
          value 0;
          description "IPv6 ORR AFI type";
        }
        enum "bgp-ipv4orr" {
          value 1;
          description "IPv4 ORR AFI type";
        }
      }
      description "Bgp orrafi";
    }

    typedef Route-target-addr-index {
      type uint32 {
        range "0..65535";
      }
      description "Route target addr index";
    }

    typedef Bgp-rpki-soft-reconf-cfg {
      type enumeration {
        enum "rpki-default-option" {
          value 0;
          description
            "Behaviour independent of RPKI validation tests
           (Disabled).";
        }
        enum "rpki-dropped-only" {
          value 1;
          description
            "Keep paths tested for RPKI in route-policy and
           dropped";
        }
        enum "rpki-tested-only" {
          value 2;
          description
            "Keep RPKI paths tested in route-policy";
        }
      }
      description "Bgp rpki soft reconf cfg";
    }

    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-asn {
      type enumeration {
        enum "as-plain" {
          value 1;
          description "AS plain format";
        }
        enum "asdot" {
          value 2;
          description "AS dot format";
        }
      }
      description "Bgp asn";
    }

    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";
        }
        enum
          "bgp-cfg-adv-vrf-evpn-re-imp-disable" {
          value 7;
          description
            "Disable adv of VRF EVPN extranet Imported
           routes";
        }
      }
      description "Bgp reorg opt";
    }

    typedef Bgp-af-encapsulation {
      type enumeration {
        enum "vx-lan" {
          value 1;
          description
            "VxLAN encapsulation type";
        }
        enum "srv6" {
          value 2;
          description
            "SRv6 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";
    }

    typedef Bgp-global-extcomm-v4-addr-index {
      type uint32 {
        range "0..65535";
      }
      description
        "Bgp global extcomm v4 addr index";
    }

    typedef Bgp-global-extcomm-asn-index {
      type uint32 {
        range "0..4294967295";
      }
      description
        "Bgp global extcomm asn index";
    }

    typedef Bgp-global-route-distinguisher {
      type enumeration {
        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 global route distinguisher";
    }

    typedef Bgp-global-as-range {
      type uint32 {
        range "0..4294967295";
      }
      description "Bgp global as range";
    }

    leaf asn-format {
      type Bgp-asn;
      default "as-plain";
      description
        "Autonomous system number format";
    }

    container bgp {
      status deprecated;
      description
        "This model is deprecated and is replaced by
       Cisco-IOS-XR-um-router-bgp-cfg.yang which will
       provide the compatible functionalities.  BGP
       configuration commands";
      list instance {
        must "instance-as" {
          description "must be set.";
        }
        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 {
          must "four-byte-as" {
            description "must be set.";
          }
          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 route-distinguisher

                  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 mvpn

                      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;
                          mandatory true;
                          description
                            "UNUSED";
                        }

                        leaf selective {
                          type boolean;
                          mandatory true;
                          description
                            "Allow multipaths only from marked
                           neighbors";
                        }

                        leaf order-by-igp-metric {
                          type boolean;
                          mandatory true;
                          description
                            "Order candidate multipaths by IGP
                           metric";
                        }
                      }  // container ebgp

                      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;
                          mandatory true;
                          description
                            "UNUSED";
                        }

                        leaf selective {
                          type boolean;
                          mandatory true;
                          description
                            "Allow multipaths only from marked
                           neighbors";
                        }

                        leaf order-by-igp-metric {
                          type boolean;
                          mandatory true;
                          description
                            "Order candidate multipaths by IGP
                           metric";
                        }
                      }  // container eibgp

                      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;
                          mandatory true;
                          description
                            "Allow multipaths to have different IGP
                           metrics";
                        }

                        leaf selective {
                          type boolean;
                          mandatory true;
                          description
                            "Allow multipaths only from marked
                           neighbors";
                        }

                        leaf order-by-igp-metric {
                          type boolean;
                          mandatory true;
                          description
                            "Order candidate multipaths by IGP
                           metric";
                        }
                      }  // container ibgp

                      leaf mpls-alloc-enable {
                        type boolean;
                        description
                          "MPLS alloc enable, use this for dual
                         mode srv6 and mpls";
                      }

                      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";
                      }

                      leaf rpki-origin-as-validation-enable {
                        type empty;
                        description
                          "RPKI origin-AS validation enable";
                      }

                      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";
                          }
                        }  // list aggregate-address
                      }  // container aggregate-addresses

                      leaf dynamic-med-interval {
                        type uint32 {
                          range "0..10";
                        }
                        units "minute";
                        default "10";
                        description
                          "Update generation delay (in minutes) after a MED
change";
                      }

                      leaf event-prefix-route-policy {
                        type string;
                        description
                          "Route Policy to mark prefixes to be traced";
                      }

                      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.";
                        }
                      }  // container dampening

                      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
.";
                      }

                      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 multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // container rip-routes

                      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";
                        }

                        leaf multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // container lisp-routes

                      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 multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // container static-routes

                      container distance {
                        presence
                          "Indicates a distance node is configured.";
                        description
                          "Define an administrative distance";
                        leaf external-routes {
                          type uint32 {
                            range "1..255";
                          }
                          mandatory true;
                          description
                            "Distance for routes external to the AS";
                        }

                        leaf internal-routes {
                          type uint32 {
                            range "1..255";
                          }
                          mandatory true;
                          description
                            "Distance for routes internal to the AS";
                        }

                        leaf local-routes {
                          type uint32 {
                            range "1..255";
                          }
                          mandatory true;
                          description
                            "Distance for local routes";
                        }
                      }  // container distance

                      leaf table-policy {
                        type string;
                        description
                          "Configure policy for installation of routes to
RIB";
                      }

                      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 multipath {
                            type boolean;
                            description
                              "Specify if Multipath, default is FALSE";
                          }
                        }  // list application-route
                      }  // container application-routes

                      leaf attribute-download {
                        type empty;
                        description
                          "Attribute download configuration";
                      }

                      container label-mode {
                        presence
                          "enable 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";
                        }
                      }  // container label-mode

                      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.";
                          }

                          leaf multipath {
                            type boolean;
                            description
                              "Specify if Multipath, default is FALSE";
                          }
                        }  // list eigrp-route
                      }  // container eigrp-routes

                      container best-external {
                        description
                          "Enable Bestexternal config";
                        leaf enable {
                          type boolean;
                          description
                            "TRUE to enable BE FALSE to disable BE
inheritance from a parent";
                        }

                        leaf labeled-unicast {
                          type boolean;
                          description
                            "Limit Best-External to Labeled-Unicast";
                        }
                      }  // container best-external

                      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";
                          }

                          leaf multipath {
                            type boolean;
                            description
                              "Specify if Multipath, default is FALSE";
                          }
                        }  // list sourced-network
                      }  // container sourced-networks

                      leaf rpki-origin-as-validity-signal-ibgp {
                        type empty;
                        description
                          "RPKI origin-AS validity signal ibgp";
                      }

                      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 multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // container connected-routes

                      leaf additional-paths-receive {
                        type dt1:Bgp-af-additional-paths-cfg;
                        description
                          "Advertise additional paths Receive capability";
                      }

                      leaf permanent-network {
                        type string;
                        description
                          "Route policy for permanent networks";
                      }

                      leaf rpki-bestpath-use-origin-as-validity {
                        type empty;
                        description
                          "RPKI bestpath use origin-AS validity";
                      }

                      container allocate-label {
                        presence
                          "enable 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";
                        }

                        leaf un-labeled-path {
                          type boolean;
                          must
                            "../all or ../route-policy-name";
                          description
                            "Allocate label for unlabeled paths too";
                        }
                      }  // container allocate-label

                      container additional-paths-selection {
                        description
                          "Configure additional paths selection";
                        leaf selection {
                          type dt1:Bgp-af-additional-paths-cfg;
                          description
                            "Enable/disable selection ";
                        }

                        leaf route-policy-name {
                          type string;
                          description
                            "Route policy for selection";
                        }
                      }  // container additional-paths-selection

                      leaf rpki-bestpath-origin-as-allow-invalid {
                        type empty;
                        description
                          "RPKI bestpath origin-AS allow invalid";
                      }

                      leaf next-hop-resolution-prefix-length-minimum {
                        type uint32 {
                          range "0..128";
                        }
                        default "0";
                        description
                          "Minimum prefix-length for nexthop resolution";
                      }

                      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";
                      }

                      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.";
                          }

                          leaf multipath {
                            type boolean;
                            description
                              "Specify if Multipath, default is FALSE";
                          }
                        }  // list ospf-route
                      }  // container ospf-routes

                      leaf additional-paths-send {
                        type dt1:Bgp-af-additional-paths-cfg;
                        description
                          "Advertise additional paths Send capability";
                      }

                      container optimal-route-reflection-group-applies {
                        description
                          "Table of multiple ORR groups";
                        list optimal-route-reflection-group-apply {
                          key "group-name";
                          description
                            "Optimal Route Reffelction group. Each such
group is equivalent to an IGP area";
                          leaf group-name {
                            type xr:Cisco-ios-xr-string;
                            description
                              "Name of the ORR group";
                          }
                        }  // list optimal-route-reflection-group-apply
                      }  // container optimal-route-reflection-group-applies

                      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";
                      }

                      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 multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // container mobile-routes

                      leaf disable-as-path-loop-check {
                        type empty;
                        description
                          "Disable outbound AS Path loop check";
                      }

                      leaf next-hop-resolution-prefix-length-minimum-ipv6 {
                        type uint32 {
                          range "0..128";
                        }
                        default "0";
                        description
                          "Minimum prefix-length for nexthop resolution";
                      }

                      container optimal-route-reflection-groups {
                        description
                          "Table of multiple ORR Groups";
                        list optimal-route-reflection-group {
                          key "group-name";
                          description
                            "Optimal Route Reffelction group. Each such
group is equivalent to an IGP area";
                          leaf group-name {
                            type xr:Cisco-ios-xr-string;
                            description
                              "Name of the ORR group";
                          }

                          leaf primary-root-address {
                            type inet:ip-address-no-zone;
                            description
                              "Primary Root for the ORR group";
                          }

                          leaf secondary-root-address {
                            type inet:ip-address-no-zone;
                            description
                              "Secondary Root for the ORR group";
                          }

                          leaf tertiary-root-address {
                            type inet:ip-address-no-zone;
                            description
                              "Tertiary Root for the ORR group";
                          }
                        }  // list optimal-route-reflection-group
                      }  // container optimal-route-reflection-groups

                      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 multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // container subscriber-routes

                      container segment-routing {
                        description
                          "Segment-routing Configurations";
                        container srv6 {
                          description
                            "SRv6 Configurations";
                          leaf enable {
                            type empty;
                            description
                              "Enable SRv6 configuration submode";
                          }

                          leaf srv6sid-allocation-mode {
                            type string;
                            description
                              "SID allocation mode: per-ce  Set per CE SID
mode,per-vrf Set per VRF SID mode";
                          }

                          leaf locator-name {
                            type string;
                            description
                              "Configure Locator name for SID allocation";
                          }
                        }  // container srv6
                      }  // container segment-routing
                    }  // list vrf-global-af
                  }  // container vrf-global-afs

                  leaf exists {
                    type empty;
                    description
                      "Create this VRF. Deletion of this object
                     causes deletion of all the objects under
                     VRF associated with this object.";
                  }

                  leaf router-id {
                    type inet:ipv4-address-no-zone;
                    default "0.0.0.0";
                    description
                      "Configure Router-id";
                  }

                  leaf slow-peer-detection-disable {
                    type empty;
                    description
                      "Disable slow peer detection.";
                  }

                  leaf disable-enforce-first-as {
                    type empty;
                    description
                      "Disable enforce the first AS for EBGP routes";
                  }

                  leaf best-path-cost-community {
                    type empty;
                    description
                      "Change default route selection criteria to
ignore cost community comparison";
                  }

                  leaf best-path-aigp-ignore {
                    type empty;
                    description
                      "Change default route selection criteria to
ignore AIGP unless both paths whichare compared
have AIGP attribute";
                  }

                  leaf best-path-igp-metric-sr-policy {
                    type empty;
                    description
                      "Enable BGP next-hop metric inheritance from SR
policy";
                  }

                  leaf next-hop-val-srte {
                    type empty;
                    description
                      "Enable BGP next-hop SR Policy reachability
validation for Extcom color paths";
                  }

                  leaf best-path-as-path-length {
                    type empty;
                    description
                      "Change default route selection criteria to
ignore AS path length";
                  }

                  leaf next-hop-val-disable {
                    type empty;
                    description
                      "Disable BGP next-hop RIB reachability validation
for Extcomm color paths";
                  }

                  leaf igp-redist-internal {
                    type empty;
                    description
                      "Allow redistribution of iBGP into IGPs
(dangerous)";
                  }

                  leaf multi-path-as-path-ignore-onwards {
                    type empty;
                    description
                      "Change default multi-route selection criteria to
ignore everything onwards as-path check";
                  }

                  leaf disable-fast-external-fallover {
                    type empty;
                    description
                      "Disable immediate reset session if a link to a
directly connected external peer goes down";
                  }

                  leaf unsafe-ebgp-policy {
                    type empty;
                    description
                      "If eBGP neighbor is configured without a
route-policy,the routes from that neighbor are
not accepted by default.This knob overrides the
default behavior. When configured,routes from
the eBGP neighbors with no policy are accepted.";
                  }

                  leaf default-metric {
                    type uint32 {
                      range "1..4294967295";
                    }
                    description
                      "Default redistributed metric";
                  }

                  leaf default-info-originate {
                    type empty;
                    description
                      "Control distribution of default information";
                  }

                  leaf rpki-origin-as-validity-signal-ibgp {
                    type empty;
                    description
                      "RPKI origin-AS validity signal ibgp";
                  }

                  leaf rpki-bestpath-use-origin-as-validity {
                    type empty;
                    description
                      "RPKI bestpath use origin-AS validity";
                  }

                  leaf best-path-confederation-paths {
                    type empty;
                    description
                      "Change default route selection criteria and
allow the comparing of MED among confederation
paths";
                  }

                  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";
                  }

                  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";
                      }
                    }  // list mpls-activated-interface
                  }  // container mpls-activated-interfaces

                  leaf disable-auto-soft-reset {
                    type empty;
                    description
                      "Disable automatic soft peer reset on policy
reconfiguration";
                  }

                  leaf disable-msg-log {
                    type empty;
                    description
                      "Disable inbound and outbound messagelogging for
all neighbors under the vrf";
                  }

                  leaf multi-path-use-cluster-list-length {
                    type empty;
                    description
                      "Change default multipath selection criteria to
consider Cluster-list length";
                  }

                  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";
                    }
                  }  // container global-timers

                  leaf best-path-igp-metric-ignore {
                    type empty;
                    description
                      "Change default route selection criteria to
ignore IGP Metric ";
                  }

                  leaf next-hop-res-allow-default {
                    type empty;
                    description
                      "Enable path resolution for nexthops using
default route";
                  }

                  leaf best-path-sr-policy-only-path {
                    type empty;
                    description
                      "Consider only paths over SR Policy for bestpath
selection";
                  }

                  leaf next-hop-mpls-fwd-ibgp {
                    type empty;
                    description
                      "Enable mpls forwarding path for ibgp learnt
nexthops";
                  }

                  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";
                    }
                  }  // container bfd

                  leaf disable-neighbor-logging {
                    type empty;
                    description
                      "Disable neighbor change logging";
                  }

                  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";
                    }
                  }  // container send-socket-buffer-sizes

                  leaf best-path-med-always {
                    type empty;
                    description
                      "Change default route selection criteria and
allow comparing of MED from different neighbors";
                  }

                  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";
                    }
                  }  // container receive-socket-buffer-sizes

                  leaf best-path-router-id {
                    type empty;
                    description
                      "Change default route selection criteria and
compare router-id for identical EBGP paths";
                  }

                  leaf best-path-med-missing {
                    type empty;
                    description
                      "Treat missing MED as the least preferred one";
                  }

                  leaf local-preference {
                    type uint32 {
                      range "0..4294967295";
                    }
                    default "100";
                    description
                      "Configure default local preference";
                  }
                }  // container vrf-global

                container vrf-neighbors {
                  description "BGP VRF peer";
                  list vrf-neighbor {
                    key "neighbor-address";
                    description
                      "A particular VRF peer";
                    leaf neighbor-address {
                      type inet:ip-address-no-zone;
                      description
                        "Neighbor address";
                    }

                    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";
                        }

                        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.";
                        }

                        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";
                        }

                        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.";
                        }

                        container aigp-cost-community {
                          description
                            "Send AIGP value in Cost Community. ";
                          leaf enable {
                            type boolean;
                            description
                              "TRUE to enable sending cost community, FALSE
otherwise ";
                          }

                          leaf cost-community-id {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type uint32 {
                              range "0..255";
                            }
                            description
                              "Cost Community ID";
                          }

                          leaf transitive {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type boolean;
                            description
                              "True to send transitive cost community FALSE
otherwise";
                          }

                          leaf cost-community-poi-type {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type Bgp-aigp-cfg-poi;
                            description
                              "Cost Community POI";
                          }
                        }  // container aigp-cost-community

                        leaf cluster-id-allow-equal {
                          type boolean;
                          description
                            "TRUE to disable cluster-id check for first id in
the cluster-id-list. FALSE to enable check for
all cluster-ids in the list.";
                        }

                        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";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v6

                        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";
                          }
                        }  // container advertise-disable

                        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";
                            }
                            mandatory true;
                            description
                              "Threshold value (%) at which to generate a
warning message.";
                          }

                          leaf warning-only {
                            type boolean;
                            mandatory true;
                            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";
                            }
                            mandatory true;
                            description
                              "Restart interval";
                          }

                          leaf discard-extra-paths {
                            type boolean;
                            mandatory true;
                            description
                              "Discard extra paths when limit is exceeded";
                          }
                        }  // container maximum-prefixes

                        container advertise-bridge-domain-imp-disable-v6 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v6

                        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.";
                          }
                        }  // container remove-private-as-entire-as-path-inbound

                        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.";
                        }

                        leaf advertise-local-labeled-route {
                          type dt1:Bgp-advertise-local-labeled-route-cfg;
                          description
                            "Enable/disable advertisement of routes with
local-label";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v4

                        leaf rpki-origin-as-validation-disable {
                          type empty;
                          description
                            "RPKI origin-AS validation disable";
                        }

                        container advertise-bridge-domain-imp-disable-v4 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v4

                        leaf flowspec-validation {
                          type Bgp-flowspec-validation-cfg;
                          description
                            "Config Flowspec validation for this neighbor";
                        }

                        container advertise-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-l2vpn-evpn

                        container advertise-local-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-local-l2vpn-evpn

                        leaf rpki-bestpath-origin-as-allow-invalid {
                          type empty;
                          description
                            "RPKI bestpath origin-AS allow invalid";
                        }

                        leaf enforce-multiple-labels {
                          type boolean;
                          description
                            "TRUE to enforce multiple labels support.";
                        }

                        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";
                        }

                        leaf multipath {
                          type empty;
                          description
                            "Allow paths from this neighbor to be eligible
for selective multipath";
                        }

                        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";
                        }

                        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.";
                        }

                        leaf prefix-orf-policy {
                          type string;
                          description
                            "Prefix ORF policy name for incoming updates";
                        }

                        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)";
                          }
                        }  // container neighbor-af-long-lived-graceful-restart-stale-time

                        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";
                          }
                        }  // container site-of-origin

                        leaf update-out-orig-loop-chk-disable {
                          type empty;
                          description
                            "Enable/disable Originator loop check for this
neighbor-group/af-group";
                        }

                        leaf aigp {
                          type Bgp-aigp-cfg;
                          description
                            "Enable Accumulated IGP Metric for this neighbor.";
                        }

                        leaf aigp-send-med {
                          type Bgp-aigp-cfg;
                          description
                            "Enable/Disable sending AIGP in MED ";
                        }

                        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";
                          }
                        }  // container advertise-v6

                        leaf allow-as-in {
                          type uint32 {
                            range "1..10";
                          }
                          default "3";
                          description
                            "Allow as-path with my AS present in it";
                        }

                        leaf advertise-orf {
                          type Bgp-orf;
                          default "none";
                          description
                            "Advertise ORF capability to the peer";
                        }

                        leaf route-reflector-client {
                          type boolean;
                          description
                            "TRUE to configure as a route-reflector-client.
FALSE to prevent route-reflector-client from
being inherited.";
                        }

                        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.";
                        }

                        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";
                          }
                        }  // container advertise-local-v6

                        container slow-peer {
                          description
                            "Slow peer detection and update group splitting";
                          leaf detection {
                            when
                              "../static = 'true' or ../static = 'false'" {
                              description
                                "../Static = 'true' or ../Static = false";
                            }
                            type boolean;
                            description
                              "Detection enable or disable";
                          }

                          leaf static {
                            type boolean;
                            description
                              "Static or dynamic split";
                          }

                          leaf dynamic-type {
                            when
                              "../static = 'false'" {
                              description
                                "../Static = false";
                            }
                            type Bgp-upd-dynamic;
                            description
                              "Dynamic or Permanent";
                          }
                        }  // container slow-peer

                        leaf route-policy-in {
                          type string;
                          description
                            "Route policy name to apply to inbound routes";
                        }

                        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";
                          }
                        }  // container import

                        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.";
                          }
                        }  // container default-originate

                        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.";
                          }

                          leaf rpki-options {
                            type Bgp-rpki-soft-reconf-cfg;
                            default
                              "rpki-default-option";
                            description
                              "Rpki tested ordropped paths should be stored";
                          }
                        }  // container soft-reconfiguration

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v6

                        leaf default-weight {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Set default weight for routes from this
neighbor/neighbor-group/af-group";
                        }

                        leaf af-group {
                          type string;
                          description
                            "Inherit configuration for this address-family
from an AF-group";
                        }

                        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";
                          }
                        }  // container advertise-v4

                        leaf optimal-route-reflection-group {
                          type string;
                          description
                            "Name of the ORR group this neighbor is going to
be part of";
                        }

                        leaf accept-own {
                          type boolean;
                          description
                            "Handle self-originated routes with Accept-Own
community. Valid for following neighbor
address-families: VPNv4Unicast, VPNv6Unicast.";
                        }

                        leaf route-policy-out {
                          type string;
                          description
                            "Route policy name to apply to outbound routes";
                        }

                        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";
                          }
                        }  // container advertise-local-v4

                        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 internal {
                            type boolean;
                            description
                              "TRUE if we need to remove private AS from
internal neighbors only. False to disable this
knob";
                          }

                          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.";
                          }
                        }  // container remove-private-as-entire-as-path

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v4
                      }  // list vrf-neighbor-af
                    }  // container vrf-neighbor-afs

                    container local-address-sub-net {
                      description
                        "Local Address subnet of routing updates";
                      leaf local-addresss-subnet {
                        type inet:ip-address-no-zone;
                        description
                          "local address subnet ip address ";
                      }

                      leaf prefix-len {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "prefix length";
                      }
                    }  // container local-address-sub-net

                    leaf internal-vpn-client-ibgp-ce {
                      type boolean;
                      description
                        "TRUE to preserve the CE path attributes.FALSE to
override CE path attributes.";
                    }

                    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 = false";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "Local ip address for neighbor";
                      }
                    }  // container local-address

                    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";
                        }
                      }  // list bmp-activate
                    }  // container bmp-activates

                    container ebgp-multihop {
                      presence
                        "Contains mandatory nodes that used to set default values";
                      description
                        "Allow EBGP neighbors not on directly connected
networks";
                      leaf max-hop-count {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Maximum hop count";
                      }

                      leaf mpls-deactivation {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE to not enable MPLS and NULL rewrite.";
                      }
                    }  // container ebgp-multihop

                    leaf session-group-add-member {
                      type string;
                      description
                        "Inherit address-family independent config from a
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";
                    }

                    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";
                      }
                    }  // container remote-as

                    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";
                      }
                    }  // container local-as

                    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";
                    }

                    leaf shutdown {
                      type boolean;
                      description
                        "TRUE to shutdown this entity, FALSE to prevent
this entity from being shutdown even if the
parent is.";
                    }

                    leaf description {
                      type string;
                      description
                        "Up to 80 characters describing this neighbor";
                    }

                    leaf suppress-extended-nexthop-encoding-capability {
                      type boolean;
                      description
                        "TRUE to suppress Extended Nexthop encoding
capability. FALSE to not suppress and to prevent
inheritance from a parent";
                    }

                    leaf neighbor-group-add-member {
                      type string;
                      description
                        "Inherit configuration from a neighbor-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 = false";
                        }
                        type xr:Proprietary-password;
                        description
                          "The neighbor password.  Leave unspecified when
disabling the password.";
                      }
                    }  // container password

                    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";
                    }

                    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";
                      }
                    }  // container advertisement-interval

                    leaf neighbor-graceful-restart {
                      type Bgp-nbrgr;
                      description
                        "TRUE to Enable graceful restart supportfor
neighbor.  FALSE to disable graceful restart
support for neighbor.";
                    }

                    leaf enforce-first-as {
                      type boolean;
                      description
                        "TRUE to enforce first AS; FALSE to not enforce
first AS.";
                    }

                    leaf idle-watch-time {
                      type uint32 {
                        range "30..1800";
                      }
                      units "second";
                      description
                        "Time to wait for deleteing IDLE state Dynamic
peer";
                    }

                    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 tcpmss

                    leaf session-open-mode {
                      type Bgp-tcp-mode;
                      default "either";
                      description
                        "TCP mode to be used to establish BGP session";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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";
                      }
                    }  // container tos

                    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";
                        }
                      }  // container update-in-filtering-message-buffers

                      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";
                      }
                    }  // container update-in-filtering

                    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";
                    }

                    container msg-log-out {
                      description
                        "Message log outbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-out

                    leaf suppress-all-capabilities {
                      type boolean;
                      description
                        "TRUE to suppress all capabilities. FALSE to not
suppress and to prevent inheritance from a
parent";
                    }

                    leaf max-peers {
                      type uint32 {
                        range "1..4096";
                      }
                      description
                        "Set Maximum Peers in Dynamic Range";
                    }

                    container ao-keychain {
                      description
                        "Set or disable AO based authentication";
                      leaf ao-keychain-disable {
                        type boolean;
                        description
                          "TRUE to prevent this entity from having AO
keychain based authentication even if the
parent has one.FALSE to enable AO keychain
based authentication";
                      }

                      leaf ao-keychain-name {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type string;
                        description
                          "Name of the AO keychain associated with this
neighbor";
                      }

                      leaf ao-include-tcp-options {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Include TCP options header with AO";
                      }

                      leaf ao-accept-mismatch-connection {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Accept new connections even though AO
mismatched";
                      }
                    }  // container ao-keychain

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    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";
                      }
                    }  // container receive-buffer-size

                    container msg-log-in {
                      description
                        "Message log inbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-in

                    leaf additional-paths-send-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    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";
                    }

                    container epe-peer-set-identities {
                      description
                        "Assign this neighbor to following peer-sets,
used for egress peer engineering";
                      list epe-peer-set-identity {
                        key "set-identity";
                        description
                          "Assign this neighbor to mentioned peer-set";
                        leaf set-identity {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identity of this EPE Peer-set";
                        }
                      }  // list epe-peer-set-identity
                    }  // container epe-peer-set-identities

                    leaf bfd-enable-modes {
                      type Bgp-bfd-enable-mode;
                      description
                        "Strict mode, Default mode or Disable to prevent
inheritance from a parent";
                    }

                    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";
                      }
                    }  // container send-buffer-size

                    leaf ttl-security {
                      type boolean;
                      description
                        "TRUE to enable BGP TTL Security.  FALSE to not
enable it and to prevent inheritance from a
parent";
                    }

                    leaf neighbor-graceful-restart-time {
                      type uint32 {
                        range "1..4095";
                      }
                      units "second";
                      default "120";
                      description
                        "Restart time advertised to neighbor";
                    }

                    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";
                      }
                    }  // container timers

                    leaf bfd-multiplier {
                      type uint32 {
                        range "2..16";
                      }
                      description
                        "Detection multiplier for BFD sessions created by
BGP";
                    }

                    leaf bfd-minimum-interval {
                      type uint32 {
                        range "3..30000";
                      }
                      units "millisecond";
                      description
                        "Hello interval for BFD sessions created by BGP";
                    }

                    leaf remote-as-list {
                      type string;
                      description
                        "Remote-as-list group name";
                    }

                    leaf labeled-unicast-equivalent-for-inbound-updates {
                      type boolean;
                      description
                        "TRUE to merge updates FALSE to not merge updates
and to prevent inheritance from a parent";
                    }

                    leaf additional-paths-receive-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    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 = false";
                        }
                        type string;
                        description
                          "Name of the keychain associated with neighbor";
                      }
                    }  // container keychain

                    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.";
                    }

                    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";
                    }

                    leaf update-source-interface {
                      type xr:Interface-name;
                      description
                        "Select an interface to configure";
                    }

                    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-local-preference

                      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";
                        }
                      }  // container graceful-maintenance-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";
                      }
                    }  // container graceful-maintenance
                  }  // list vrf-neighbor

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

                    leaf prefix-length {
                      type uint32 {
                        range "0..127";
                      }
                      description
                        "Prefix length";
                    }

                    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";
                        }

                        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.";
                        }

                        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";
                        }

                        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.";
                        }

                        container aigp-cost-community {
                          description
                            "Send AIGP value in Cost Community. ";
                          leaf enable {
                            type boolean;
                            description
                              "TRUE to enable sending cost community, FALSE
otherwise ";
                          }

                          leaf cost-community-id {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type uint32 {
                              range "0..255";
                            }
                            description
                              "Cost Community ID";
                          }

                          leaf transitive {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type boolean;
                            description
                              "True to send transitive cost community FALSE
otherwise";
                          }

                          leaf cost-community-poi-type {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type Bgp-aigp-cfg-poi;
                            description
                              "Cost Community POI";
                          }
                        }  // container aigp-cost-community

                        leaf cluster-id-allow-equal {
                          type boolean;
                          description
                            "TRUE to disable cluster-id check for first id in
the cluster-id-list. FALSE to enable check for
all cluster-ids in the list.";
                        }

                        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";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v6

                        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";
                          }
                        }  // container advertise-disable

                        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";
                            }
                            mandatory true;
                            description
                              "Threshold value (%) at which to generate a
warning message.";
                          }

                          leaf warning-only {
                            type boolean;
                            mandatory true;
                            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";
                            }
                            mandatory true;
                            description
                              "Restart interval";
                          }

                          leaf discard-extra-paths {
                            type boolean;
                            mandatory true;
                            description
                              "Discard extra paths when limit is exceeded";
                          }
                        }  // container maximum-prefixes

                        container advertise-bridge-domain-imp-disable-v6 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v6

                        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.";
                          }
                        }  // container remove-private-as-entire-as-path-inbound

                        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.";
                        }

                        leaf advertise-local-labeled-route {
                          type dt1:Bgp-advertise-local-labeled-route-cfg;
                          description
                            "Enable/disable advertisement of routes with
local-label";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v4

                        leaf rpki-origin-as-validation-disable {
                          type empty;
                          description
                            "RPKI origin-AS validation disable";
                        }

                        container advertise-bridge-domain-imp-disable-v4 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v4

                        leaf flowspec-validation {
                          type Bgp-flowspec-validation-cfg;
                          description
                            "Config Flowspec validation for this neighbor";
                        }

                        container advertise-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-l2vpn-evpn

                        container advertise-local-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-local-l2vpn-evpn

                        leaf rpki-bestpath-origin-as-allow-invalid {
                          type empty;
                          description
                            "RPKI bestpath origin-AS allow invalid";
                        }

                        leaf enforce-multiple-labels {
                          type boolean;
                          description
                            "TRUE to enforce multiple labels support.";
                        }

                        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";
                        }

                        leaf multipath {
                          type empty;
                          description
                            "Allow paths from this neighbor to be eligible
for selective multipath";
                        }

                        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";
                        }

                        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.";
                        }

                        leaf prefix-orf-policy {
                          type string;
                          description
                            "Prefix ORF policy name for incoming updates";
                        }

                        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)";
                          }
                        }  // container neighbor-af-long-lived-graceful-restart-stale-time

                        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";
                          }
                        }  // container site-of-origin

                        leaf update-out-orig-loop-chk-disable {
                          type empty;
                          description
                            "Enable/disable Originator loop check for this
neighbor-group/af-group";
                        }

                        leaf aigp {
                          type Bgp-aigp-cfg;
                          description
                            "Enable Accumulated IGP Metric for this neighbor.";
                        }

                        leaf aigp-send-med {
                          type Bgp-aigp-cfg;
                          description
                            "Enable/Disable sending AIGP in MED ";
                        }

                        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";
                          }
                        }  // container advertise-v6

                        leaf allow-as-in {
                          type uint32 {
                            range "1..10";
                          }
                          default "3";
                          description
                            "Allow as-path with my AS present in it";
                        }

                        leaf advertise-orf {
                          type Bgp-orf;
                          default "none";
                          description
                            "Advertise ORF capability to the peer";
                        }

                        leaf route-reflector-client {
                          type boolean;
                          description
                            "TRUE to configure as a route-reflector-client.
FALSE to prevent route-reflector-client from
being inherited.";
                        }

                        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.";
                        }

                        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";
                          }
                        }  // container advertise-local-v6

                        container slow-peer {
                          description
                            "Slow peer detection and update group splitting";
                          leaf detection {
                            when
                              "../static = 'true' or ../static = 'false'" {
                              description
                                "../Static = 'true' or ../Static = false";
                            }
                            type boolean;
                            description
                              "Detection enable or disable";
                          }

                          leaf static {
                            type boolean;
                            description
                              "Static or dynamic split";
                          }

                          leaf dynamic-type {
                            when
                              "../static = 'false'" {
                              description
                                "../Static = false";
                            }
                            type Bgp-upd-dynamic;
                            description
                              "Dynamic or Permanent";
                          }
                        }  // container slow-peer

                        leaf route-policy-in {
                          type string;
                          description
                            "Route policy name to apply to inbound routes";
                        }

                        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";
                          }
                        }  // container import

                        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.";
                          }
                        }  // container default-originate

                        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.";
                          }

                          leaf rpki-options {
                            type Bgp-rpki-soft-reconf-cfg;
                            default
                              "rpki-default-option";
                            description
                              "Rpki tested ordropped paths should be stored";
                          }
                        }  // container soft-reconfiguration

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v6

                        leaf default-weight {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Set default weight for routes from this
neighbor/neighbor-group/af-group";
                        }

                        leaf af-group {
                          type string;
                          description
                            "Inherit configuration for this address-family
from an AF-group";
                        }

                        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";
                          }
                        }  // container advertise-v4

                        leaf optimal-route-reflection-group {
                          type string;
                          description
                            "Name of the ORR group this neighbor is going to
be part of";
                        }

                        leaf accept-own {
                          type boolean;
                          description
                            "Handle self-originated routes with Accept-Own
community. Valid for following neighbor
address-families: VPNv4Unicast, VPNv6Unicast.";
                        }

                        leaf route-policy-out {
                          type string;
                          description
                            "Route policy name to apply to outbound routes";
                        }

                        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";
                          }
                        }  // container advertise-local-v4

                        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 internal {
                            type boolean;
                            description
                              "TRUE if we need to remove private AS from
internal neighbors only. False to disable this
knob";
                          }

                          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.";
                          }
                        }  // container remove-private-as-entire-as-path

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v4
                      }  // list vrf-neighbor-af
                    }  // container vrf-neighbor-afs

                    container local-address-sub-net {
                      description
                        "Local Address subnet of routing updates";
                      leaf local-addresss-subnet {
                        type inet:ip-address-no-zone;
                        description
                          "local address subnet ip address ";
                      }

                      leaf prefix-len {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "prefix length";
                      }
                    }  // container local-address-sub-net

                    leaf internal-vpn-client-ibgp-ce {
                      type boolean;
                      description
                        "TRUE to preserve the CE path attributes.FALSE to
override CE path attributes.";
                    }

                    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 = false";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "Local ip address for neighbor";
                      }
                    }  // container local-address

                    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";
                        }
                      }  // list bmp-activate
                    }  // container bmp-activates

                    container ebgp-multihop {
                      presence
                        "Contains mandatory nodes that used to set default values";
                      description
                        "Allow EBGP neighbors not on directly connected
networks";
                      leaf max-hop-count {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Maximum hop count";
                      }

                      leaf mpls-deactivation {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE to not enable MPLS and NULL rewrite.";
                      }
                    }  // container ebgp-multihop

                    leaf session-group-add-member {
                      type string;
                      description
                        "Inherit address-family independent config from a
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";
                    }

                    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";
                      }
                    }  // container remote-as

                    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";
                      }
                    }  // container local-as

                    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";
                    }

                    leaf shutdown {
                      type boolean;
                      description
                        "TRUE to shutdown this entity, FALSE to prevent
this entity from being shutdown even if the
parent is.";
                    }

                    leaf description {
                      type string;
                      description
                        "Up to 80 characters describing this neighbor";
                    }

                    leaf suppress-extended-nexthop-encoding-capability {
                      type boolean;
                      description
                        "TRUE to suppress Extended Nexthop encoding
capability. FALSE to not suppress and to prevent
inheritance from a parent";
                    }

                    leaf neighbor-group-add-member {
                      type string;
                      description
                        "Inherit configuration from a neighbor-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 = false";
                        }
                        type xr:Proprietary-password;
                        description
                          "The neighbor password.  Leave unspecified when
disabling the password.";
                      }
                    }  // container password

                    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";
                    }

                    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";
                      }
                    }  // container advertisement-interval

                    leaf neighbor-graceful-restart {
                      type Bgp-nbrgr;
                      description
                        "TRUE to Enable graceful restart supportfor
neighbor.  FALSE to disable graceful restart
support for neighbor.";
                    }

                    leaf enforce-first-as {
                      type boolean;
                      description
                        "TRUE to enforce first AS; FALSE to not enforce
first AS.";
                    }

                    leaf idle-watch-time {
                      type uint32 {
                        range "30..1800";
                      }
                      units "second";
                      description
                        "Time to wait for deleteing IDLE state Dynamic
peer";
                    }

                    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 tcpmss

                    leaf session-open-mode {
                      type Bgp-tcp-mode;
                      default "either";
                      description
                        "TCP mode to be used to establish BGP session";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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";
                      }
                    }  // container tos

                    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";
                        }
                      }  // container update-in-filtering-message-buffers

                      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";
                      }
                    }  // container update-in-filtering

                    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";
                    }

                    container msg-log-out {
                      description
                        "Message log outbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-out

                    leaf suppress-all-capabilities {
                      type boolean;
                      description
                        "TRUE to suppress all capabilities. FALSE to not
suppress and to prevent inheritance from a
parent";
                    }

                    leaf max-peers {
                      type uint32 {
                        range "1..4096";
                      }
                      description
                        "Set Maximum Peers in Dynamic Range";
                    }

                    container ao-keychain {
                      description
                        "Set or disable AO based authentication";
                      leaf ao-keychain-disable {
                        type boolean;
                        description
                          "TRUE to prevent this entity from having AO
keychain based authentication even if the
parent has one.FALSE to enable AO keychain
based authentication";
                      }

                      leaf ao-keychain-name {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type string;
                        description
                          "Name of the AO keychain associated with this
neighbor";
                      }

                      leaf ao-include-tcp-options {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Include TCP options header with AO";
                      }

                      leaf ao-accept-mismatch-connection {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Accept new connections even though AO
mismatched";
                      }
                    }  // container ao-keychain

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    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";
                      }
                    }  // container receive-buffer-size

                    container msg-log-in {
                      description
                        "Message log inbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-in

                    leaf additional-paths-send-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    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";
                    }

                    container epe-peer-set-identities {
                      description
                        "Assign this neighbor to following peer-sets,
used for egress peer engineering";
                      list epe-peer-set-identity {
                        key "set-identity";
                        description
                          "Assign this neighbor to mentioned peer-set";
                        leaf set-identity {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identity of this EPE Peer-set";
                        }
                      }  // list epe-peer-set-identity
                    }  // container epe-peer-set-identities

                    leaf bfd-enable-modes {
                      type Bgp-bfd-enable-mode;
                      description
                        "Strict mode, Default mode or Disable to prevent
inheritance from a parent";
                    }

                    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";
                      }
                    }  // container send-buffer-size

                    leaf ttl-security {
                      type boolean;
                      description
                        "TRUE to enable BGP TTL Security.  FALSE to not
enable it and to prevent inheritance from a
parent";
                    }

                    leaf neighbor-graceful-restart-time {
                      type uint32 {
                        range "1..4095";
                      }
                      units "second";
                      default "120";
                      description
                        "Restart time advertised to neighbor";
                    }

                    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";
                      }
                    }  // container timers

                    leaf bfd-multiplier {
                      type uint32 {
                        range "2..16";
                      }
                      description
                        "Detection multiplier for BFD sessions created by
BGP";
                    }

                    leaf bfd-minimum-interval {
                      type uint32 {
                        range "3..30000";
                      }
                      units "millisecond";
                      description
                        "Hello interval for BFD sessions created by BGP";
                    }

                    leaf remote-as-list {
                      type string;
                      description
                        "Remote-as-list group name";
                    }

                    leaf labeled-unicast-equivalent-for-inbound-updates {
                      type boolean;
                      description
                        "TRUE to merge updates FALSE to not merge updates
and to prevent inheritance from a parent";
                    }

                    leaf additional-paths-receive-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    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 = false";
                        }
                        type string;
                        description
                          "Name of the keychain associated with neighbor";
                      }
                    }  // container keychain

                    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.";
                    }

                    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";
                    }

                    leaf update-source-interface {
                      type xr:Interface-name;
                      description
                        "Select an interface to configure";
                    }

                    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-local-preference

                      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";
                        }
                      }  // container graceful-maintenance-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";
                      }
                    }  // container graceful-maintenance
                  }  // list vrf-neighbor-prefix-length
                }  // container vrf-neighbors

                leaf vrf-name {
                  type xr:Cisco-ios-xr-string;
                  description "VRF name";
                }
              }  // list vrf
            }  // container vrfs

            container default-vrf {
              description
                "Global default config";
              container bgp-entity {
                description
                  "Neighbor, neighbor-group, af-group and
                 session-group configuration";
                container neighbors {
                  description
                    "Neighbor configuration";
                  list neighbor {
                    key "neighbor-address";
                    description
                      "A particular BGP peer";
                    leaf neighbor-address {
                      type inet:ip-address-no-zone;
                      description
                        "Neighbor address";
                    }

                    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";
                        }

                        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.";
                        }

                        leaf l2vpn-signalling {
                          type Bgp-signal;
                          description
                            "Disable signalling type on the peer";
                        }

                        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";
                        }

                        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.";
                        }

                        container aigp-cost-community {
                          description
                            "Send AIGP value in Cost Community. ";
                          leaf enable {
                            type boolean;
                            description
                              "TRUE to enable sending cost community, FALSE
otherwise ";
                          }

                          leaf cost-community-id {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type uint32 {
                              range "0..255";
                            }
                            description
                              "Cost Community ID";
                          }

                          leaf transitive {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type boolean;
                            description
                              "True to send transitive cost community FALSE
otherwise";
                          }

                          leaf cost-community-poi-type {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type Bgp-aigp-cfg-poi;
                            description
                              "Cost Community POI";
                          }
                        }  // container aigp-cost-community

                        leaf cluster-id-allow-equal {
                          type boolean;
                          description
                            "TRUE to disable cluster-id check for first id in
the cluster-id-list. FALSE to enable check for
all cluster-ids in the list.";
                        }

                        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";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v6

                        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";
                          }
                        }  // container advertise-disable

                        leaf send-multicast-attr {
                          type Bgp-send-mcast-attr-cfg;
                          description
                            "Config send multicast attribute for this
neighbor";
                        }

                        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";
                            }
                            mandatory true;
                            description
                              "Threshold value (%) at which to generate a
warning message.";
                          }

                          leaf warning-only {
                            type boolean;
                            mandatory true;
                            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";
                            }
                            mandatory true;
                            description
                              "Restart interval";
                          }

                          leaf discard-extra-paths {
                            type boolean;
                            mandatory true;
                            description
                              "Discard extra paths when limit is exceeded";
                          }
                        }  // container maximum-prefixes

                        container advertise-bridge-domain-imp-disable-v6 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v6

                        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.";
                          }
                        }  // container remove-private-as-entire-as-path-inbound

                        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.";
                        }

                        leaf advertise-local-labeled-route {
                          type dt1:Bgp-advertise-local-labeled-route-cfg;
                          description
                            "Enable/disable advertisement of routes with
local-label";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v4

                        leaf rpki-origin-as-validation-disable {
                          type empty;
                          description
                            "RPKI origin-AS validation disable";
                        }

                        container advertise-bridge-domain-imp-disable-v4 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v4

                        leaf flowspec-validation {
                          type Bgp-flowspec-validation-cfg;
                          description
                            "Config Flowspec validation for this neighbor";
                        }

                        container advertise-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-l2vpn-evpn

                        container advertise-local-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-local-l2vpn-evpn

                        leaf encapsulation-type {
                          type Bgp-af-encapsulation;
                          description
                            "Encapsulation type for this neighbor";
                        }

                        leaf rpki-bestpath-origin-as-allow-invalid {
                          type empty;
                          description
                            "RPKI bestpath origin-AS allow invalid";
                        }

                        leaf enforce-multiple-labels {
                          type boolean;
                          description
                            "TRUE to enforce multiple labels support.";
                        }

                        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";
                        }

                        leaf multipath {
                          type empty;
                          description
                            "Allow paths from this neighbor to be eligible
for selective multipath";
                        }

                        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";
                        }

                        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.";
                        }

                        leaf prefix-orf-policy {
                          type string;
                          description
                            "Prefix ORF policy name for incoming updates";
                        }

                        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)";
                          }
                        }  // container neighbor-af-long-lived-graceful-restart-stale-time

                        leaf update-out-orig-loop-chk-disable {
                          type empty;
                          description
                            "Enable/disable Originator loop check for this
neighbor-group/af-group";
                        }

                        leaf aigp {
                          type Bgp-aigp-cfg;
                          description
                            "Enable Accumulated IGP Metric for this neighbor.";
                        }

                        leaf aigp-send-med {
                          type Bgp-aigp-cfg;
                          description
                            "Enable/Disable sending AIGP in MED ";
                        }

                        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";
                          }
                        }  // container advertise-v6

                        leaf allow-as-in {
                          type uint32 {
                            range "1..10";
                          }
                          default "3";
                          description
                            "Allow as-path with my AS present in it";
                        }

                        leaf advertise-orf {
                          type Bgp-orf;
                          default "none";
                          description
                            "Advertise ORF capability to the peer";
                        }

                        leaf route-reflector-client {
                          type boolean;
                          description
                            "TRUE to configure as a route-reflector-client.
FALSE to prevent route-reflector-client from
being inherited.";
                        }

                        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.";
                        }

                        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";
                          }
                        }  // container advertise-local-v6

                        leaf srv6version4 {
                          type boolean;
                          description
                            "TRUE to enable SRv6 version 4,FALSE to disable
SRv6 version 4";
                        }

                        container slow-peer {
                          description
                            "Slow peer detection and update group splitting";
                          leaf detection {
                            when
                              "../static = 'true' or ../static = 'false'" {
                              description
                                "../Static = 'true' or ../Static = false";
                            }
                            type boolean;
                            description
                              "Detection enable or disable";
                          }

                          leaf static {
                            type boolean;
                            description
                              "Static or dynamic split";
                          }

                          leaf dynamic-type {
                            when
                              "../static = 'false'" {
                              description
                                "../Static = false";
                            }
                            type Bgp-upd-dynamic;
                            description
                              "Dynamic or Permanent";
                          }
                        }  // container slow-peer

                        leaf route-policy-in {
                          type string;
                          description
                            "Route policy name to apply to inbound routes";
                        }

                        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";
                          }
                        }  // container import

                        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.";
                          }
                        }  // container default-originate

                        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.";
                          }

                          leaf rpki-options {
                            type Bgp-rpki-soft-reconf-cfg;
                            default
                              "rpki-default-option";
                            description
                              "Rpki tested ordropped paths should be stored";
                          }
                        }  // container soft-reconfiguration

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v6

                        leaf default-weight {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Set default weight for routes from this
neighbor/neighbor-group/af-group";
                        }

                        leaf af-group {
                          type string;
                          description
                            "Inherit configuration for this address-family
from an AF-group";
                        }

                        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";
                          }
                        }  // container advertise-v4

                        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.";
                        }

                        leaf optimal-route-reflection-group {
                          type string;
                          description
                            "Name of the ORR group this neighbor is going to
be part of";
                        }

                        leaf accept-own {
                          type boolean;
                          description
                            "Handle self-originated routes with Accept-Own
community. Valid for following neighbor
address-families: VPNv4Unicast, VPNv6Unicast.";
                        }

                        leaf route-policy-out {
                          type string;
                          description
                            "Route policy name to apply to outbound routes";
                        }

                        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";
                          }
                        }  // container advertise-local-v4

                        leaf advertise-permanent-network {
                          type empty;
                          description
                            "Advertise Permanent Networks to the peer";
                        }

                        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 internal {
                            type boolean;
                            description
                              "TRUE if we need to remove private AS from
internal neighbors only. False to disable this
knob";
                          }

                          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.";
                          }
                        }  // container remove-private-as-entire-as-path

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v4
                      }  // list neighbor-af
                    }  // container neighbor-afs

                    leaf epe-peer-node-sid {
                      type uint32 {
                        range "0..1033575";
                      }
                      description
                        "Manual Segment Index assigned to this
peer for egress peer engineering";
                    }

                    container local-address-sub-net {
                      description
                        "Local Address subnet of routing updates";
                      leaf local-addresss-subnet {
                        type inet:ip-address-no-zone;
                        description
                          "local address subnet ip address ";
                      }

                      leaf prefix-len {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "prefix length";
                      }
                    }  // container local-address-sub-net

                    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 = false";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "Local ip address for neighbor";
                      }
                    }  // container local-address

                    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";
                        }
                      }  // list bmp-activate
                    }  // container bmp-activates

                    container ebgp-multihop {
                      presence
                        "Contains mandatory nodes that used to set default values";
                      description
                        "Allow EBGP neighbors not on directly connected
networks";
                      leaf max-hop-count {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Maximum hop count";
                      }

                      leaf mpls-deactivation {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE to not enable MPLS and NULL rewrite.";
                      }
                    }  // container ebgp-multihop

                    leaf session-group-add-member {
                      type string;
                      description
                        "Inherit address-family independent config from a
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";
                    }

                    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";
                      }
                    }  // container remote-as

                    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";
                      }
                    }  // container local-as

                    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";
                    }

                    leaf shutdown {
                      type boolean;
                      description
                        "TRUE to shutdown this entity, FALSE to prevent
this entity from being shutdown even if the
parent is.";
                    }

                    leaf description {
                      type string;
                      description
                        "Up to 80 characters describing this neighbor";
                    }

                    leaf suppress-extended-nexthop-encoding-capability {
                      type boolean;
                      description
                        "TRUE to suppress Extended Nexthop encoding
capability. FALSE to not suppress and to prevent
inheritance from a parent";
                    }

                    leaf neighbor-group-add-member {
                      type string;
                      description
                        "Inherit configuration from a neighbor-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 = false";
                        }
                        type xr:Proprietary-password;
                        description
                          "The neighbor password.  Leave unspecified when
disabling the password.";
                      }
                    }  // container password

                    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";
                    }

                    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";
                      }
                    }  // container advertisement-interval

                    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";
                      }
                    }  // container neighbor-cluster-id

                    leaf neighbor-graceful-restart {
                      type Bgp-nbrgr;
                      description
                        "TRUE to Enable graceful restart supportfor
neighbor.  FALSE to disable graceful restart
support for neighbor.";
                    }

                    leaf enforce-first-as {
                      type boolean;
                      description
                        "TRUE to enforce first AS; FALSE to not enforce
first AS.";
                    }

                    leaf idle-watch-time {
                      type uint32 {
                        range "30..1800";
                      }
                      units "second";
                      description
                        "Time to wait for deleteing IDLE state Dynamic
peer";
                    }

                    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 tcpmss

                    leaf session-open-mode {
                      type Bgp-tcp-mode;
                      default "either";
                      description
                        "TCP mode to be used to establish BGP session";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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";
                      }
                    }  // container tos

                    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";
                        }
                      }  // container update-in-filtering-message-buffers

                      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";
                      }
                    }  // container update-in-filtering

                    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";
                    }

                    container msg-log-out {
                      description
                        "Message log outbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-out

                    leaf suppress-all-capabilities {
                      type boolean;
                      description
                        "TRUE to suppress all capabilities. FALSE to not
suppress and to prevent inheritance from a
parent";
                    }

                    leaf max-peers {
                      type uint32 {
                        range "1..4096";
                      }
                      description
                        "Set Maximum Peers in Dynamic Range";
                    }

                    container ao-keychain {
                      description
                        "Set or disable AO based authentication";
                      leaf ao-keychain-disable {
                        type boolean;
                        description
                          "TRUE to prevent this entity from having AO
keychain based authentication even if the
parent has one.FALSE to enable AO keychain
based authentication";
                      }

                      leaf ao-keychain-name {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type string;
                        description
                          "Name of the AO keychain associated with this
neighbor";
                      }

                      leaf ao-include-tcp-options {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Include TCP options header with AO";
                      }

                      leaf ao-accept-mismatch-connection {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Accept new connections even though AO
mismatched";
                      }
                    }  // container ao-keychain

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    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";
                      }
                    }  // container receive-buffer-size

                    container msg-log-in {
                      description
                        "Message log inbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-in

                    leaf additional-paths-send-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    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";
                    }

                    container epe-peer-set-identities {
                      description
                        "Assign this neighbor to following peer-sets,
used for egress peer engineering";
                      list epe-peer-set-identity {
                        key "set-identity";
                        description
                          "Assign this neighbor to mentioned peer-set";
                        leaf set-identity {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identity of this EPE Peer-set";
                        }
                      }  // list epe-peer-set-identity
                    }  // container epe-peer-set-identities

                    leaf bfd-enable-modes {
                      type Bgp-bfd-enable-mode;
                      description
                        "Strict mode, Default mode or Disable to prevent
inheritance from a parent";
                    }

                    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";
                      }
                    }  // container send-buffer-size

                    leaf ttl-security {
                      type boolean;
                      description
                        "TRUE to enable BGP TTL Security.  FALSE to not
enable it and to prevent inheritance from a
parent";
                    }

                    leaf neighbor-graceful-restart-time {
                      type uint32 {
                        range "1..4095";
                      }
                      units "second";
                      default "120";
                      description
                        "Restart time advertised to neighbor";
                    }

                    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";
                      }
                    }  // container timers

                    leaf bfd-multiplier {
                      type uint32 {
                        range "2..16";
                      }
                      description
                        "Detection multiplier for BFD sessions created by
BGP";
                    }

                    leaf bfd-minimum-interval {
                      type uint32 {
                        range "3..30000";
                      }
                      units "millisecond";
                      description
                        "Hello interval for BFD sessions created by BGP";
                    }

                    leaf remote-as-list {
                      type string;
                      description
                        "Remote-as-list group name";
                    }

                    leaf labeled-unicast-equivalent-for-inbound-updates {
                      type boolean;
                      description
                        "TRUE to merge updates FALSE to not merge updates
and to prevent inheritance from a parent";
                    }

                    leaf additional-paths-receive-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    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 = false";
                        }
                        type string;
                        description
                          "Name of the keychain associated with neighbor";
                      }
                    }  // container keychain

                    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.";
                    }

                    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";
                    }

                    leaf update-source-interface {
                      type xr:Interface-name;
                      description
                        "Select an interface to configure";
                    }

                    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-local-preference

                      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";
                        }
                      }  // container graceful-maintenance-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";
                      }
                    }  // container graceful-maintenance
                  }  // list neighbor

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

                    leaf prefix-length {
                      type uint32 {
                        range "0..127";
                      }
                      description
                        "Prefix length";
                    }

                    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";
                        }

                        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.";
                        }

                        leaf l2vpn-signalling {
                          type Bgp-signal;
                          description
                            "Disable signalling type on the peer";
                        }

                        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";
                        }

                        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.";
                        }

                        container aigp-cost-community {
                          description
                            "Send AIGP value in Cost Community. ";
                          leaf enable {
                            type boolean;
                            description
                              "TRUE to enable sending cost community, FALSE
otherwise ";
                          }

                          leaf cost-community-id {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type uint32 {
                              range "0..255";
                            }
                            description
                              "Cost Community ID";
                          }

                          leaf transitive {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type boolean;
                            description
                              "True to send transitive cost community FALSE
otherwise";
                          }

                          leaf cost-community-poi-type {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type Bgp-aigp-cfg-poi;
                            description
                              "Cost Community POI";
                          }
                        }  // container aigp-cost-community

                        leaf cluster-id-allow-equal {
                          type boolean;
                          description
                            "TRUE to disable cluster-id check for first id in
the cluster-id-list. FALSE to enable check for
all cluster-ids in the list.";
                        }

                        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";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v6

                        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";
                          }
                        }  // container advertise-disable

                        leaf send-multicast-attr {
                          type Bgp-send-mcast-attr-cfg;
                          description
                            "Config send multicast attribute for this
neighbor";
                        }

                        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";
                            }
                            mandatory true;
                            description
                              "Threshold value (%) at which to generate a
warning message.";
                          }

                          leaf warning-only {
                            type boolean;
                            mandatory true;
                            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";
                            }
                            mandatory true;
                            description
                              "Restart interval";
                          }

                          leaf discard-extra-paths {
                            type boolean;
                            mandatory true;
                            description
                              "Discard extra paths when limit is exceeded";
                          }
                        }  // container maximum-prefixes

                        container advertise-bridge-domain-imp-disable-v6 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v6

                        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.";
                          }
                        }  // container remove-private-as-entire-as-path-inbound

                        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.";
                        }

                        leaf advertise-local-labeled-route {
                          type dt1:Bgp-advertise-local-labeled-route-cfg;
                          description
                            "Enable/disable advertisement of routes with
local-label";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v4

                        leaf rpki-origin-as-validation-disable {
                          type empty;
                          description
                            "RPKI origin-AS validation disable";
                        }

                        container advertise-bridge-domain-imp-disable-v4 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v4

                        leaf flowspec-validation {
                          type Bgp-flowspec-validation-cfg;
                          description
                            "Config Flowspec validation for this neighbor";
                        }

                        container advertise-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-l2vpn-evpn

                        container advertise-local-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-local-l2vpn-evpn

                        leaf encapsulation-type {
                          type Bgp-af-encapsulation;
                          description
                            "Encapsulation type for this neighbor";
                        }

                        leaf rpki-bestpath-origin-as-allow-invalid {
                          type empty;
                          description
                            "RPKI bestpath origin-AS allow invalid";
                        }

                        leaf enforce-multiple-labels {
                          type boolean;
                          description
                            "TRUE to enforce multiple labels support.";
                        }

                        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";
                        }

                        leaf multipath {
                          type empty;
                          description
                            "Allow paths from this neighbor to be eligible
for selective multipath";
                        }

                        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";
                        }

                        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.";
                        }

                        leaf prefix-orf-policy {
                          type string;
                          description
                            "Prefix ORF policy name for incoming updates";
                        }

                        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)";
                          }
                        }  // container neighbor-af-long-lived-graceful-restart-stale-time

                        leaf update-out-orig-loop-chk-disable {
                          type empty;
                          description
                            "Enable/disable Originator loop check for this
neighbor-group/af-group";
                        }

                        leaf aigp {
                          type Bgp-aigp-cfg;
                          description
                            "Enable Accumulated IGP Metric for this neighbor.";
                        }

                        leaf aigp-send-med {
                          type Bgp-aigp-cfg;
                          description
                            "Enable/Disable sending AIGP in MED ";
                        }

                        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";
                          }
                        }  // container advertise-v6

                        leaf allow-as-in {
                          type uint32 {
                            range "1..10";
                          }
                          default "3";
                          description
                            "Allow as-path with my AS present in it";
                        }

                        leaf advertise-orf {
                          type Bgp-orf;
                          default "none";
                          description
                            "Advertise ORF capability to the peer";
                        }

                        leaf route-reflector-client {
                          type boolean;
                          description
                            "TRUE to configure as a route-reflector-client.
FALSE to prevent route-reflector-client from
being inherited.";
                        }

                        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.";
                        }

                        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";
                          }
                        }  // container advertise-local-v6

                        leaf srv6version4 {
                          type boolean;
                          description
                            "TRUE to enable SRv6 version 4,FALSE to disable
SRv6 version 4";
                        }

                        container slow-peer {
                          description
                            "Slow peer detection and update group splitting";
                          leaf detection {
                            when
                              "../static = 'true' or ../static = 'false'" {
                              description
                                "../Static = 'true' or ../Static = false";
                            }
                            type boolean;
                            description
                              "Detection enable or disable";
                          }

                          leaf static {
                            type boolean;
                            description
                              "Static or dynamic split";
                          }

                          leaf dynamic-type {
                            when
                              "../static = 'false'" {
                              description
                                "../Static = false";
                            }
                            type Bgp-upd-dynamic;
                            description
                              "Dynamic or Permanent";
                          }
                        }  // container slow-peer

                        leaf route-policy-in {
                          type string;
                          description
                            "Route policy name to apply to inbound routes";
                        }

                        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";
                          }
                        }  // container import

                        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.";
                          }
                        }  // container default-originate

                        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.";
                          }

                          leaf rpki-options {
                            type Bgp-rpki-soft-reconf-cfg;
                            default
                              "rpki-default-option";
                            description
                              "Rpki tested ordropped paths should be stored";
                          }
                        }  // container soft-reconfiguration

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v6

                        leaf default-weight {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Set default weight for routes from this
neighbor/neighbor-group/af-group";
                        }

                        leaf af-group {
                          type string;
                          description
                            "Inherit configuration for this address-family
from an AF-group";
                        }

                        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";
                          }
                        }  // container advertise-v4

                        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.";
                        }

                        leaf optimal-route-reflection-group {
                          type string;
                          description
                            "Name of the ORR group this neighbor is going to
be part of";
                        }

                        leaf accept-own {
                          type boolean;
                          description
                            "Handle self-originated routes with Accept-Own
community. Valid for following neighbor
address-families: VPNv4Unicast, VPNv6Unicast.";
                        }

                        leaf route-policy-out {
                          type string;
                          description
                            "Route policy name to apply to outbound routes";
                        }

                        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";
                          }
                        }  // container advertise-local-v4

                        leaf advertise-permanent-network {
                          type empty;
                          description
                            "Advertise Permanent Networks to the peer";
                        }

                        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 internal {
                            type boolean;
                            description
                              "TRUE if we need to remove private AS from
internal neighbors only. False to disable this
knob";
                          }

                          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.";
                          }
                        }  // container remove-private-as-entire-as-path

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v4
                      }  // list neighbor-af
                    }  // container neighbor-afs

                    leaf epe-peer-node-sid {
                      type uint32 {
                        range "0..1033575";
                      }
                      description
                        "Manual Segment Index assigned to this
peer for egress peer engineering";
                    }

                    container local-address-sub-net {
                      description
                        "Local Address subnet of routing updates";
                      leaf local-addresss-subnet {
                        type inet:ip-address-no-zone;
                        description
                          "local address subnet ip address ";
                      }

                      leaf prefix-len {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "prefix length";
                      }
                    }  // container local-address-sub-net

                    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 = false";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "Local ip address for neighbor";
                      }
                    }  // container local-address

                    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";
                        }
                      }  // list bmp-activate
                    }  // container bmp-activates

                    container ebgp-multihop {
                      presence
                        "Contains mandatory nodes that used to set default values";
                      description
                        "Allow EBGP neighbors not on directly connected
networks";
                      leaf max-hop-count {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Maximum hop count";
                      }

                      leaf mpls-deactivation {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE to not enable MPLS and NULL rewrite.";
                      }
                    }  // container ebgp-multihop

                    leaf session-group-add-member {
                      type string;
                      description
                        "Inherit address-family independent config from a
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";
                    }

                    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";
                      }
                    }  // container remote-as

                    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";
                      }
                    }  // container local-as

                    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";
                    }

                    leaf shutdown {
                      type boolean;
                      description
                        "TRUE to shutdown this entity, FALSE to prevent
this entity from being shutdown even if the
parent is.";
                    }

                    leaf description {
                      type string;
                      description
                        "Up to 80 characters describing this neighbor";
                    }

                    leaf suppress-extended-nexthop-encoding-capability {
                      type boolean;
                      description
                        "TRUE to suppress Extended Nexthop encoding
capability. FALSE to not suppress and to prevent
inheritance from a parent";
                    }

                    leaf neighbor-group-add-member {
                      type string;
                      description
                        "Inherit configuration from a neighbor-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 = false";
                        }
                        type xr:Proprietary-password;
                        description
                          "The neighbor password.  Leave unspecified when
disabling the password.";
                      }
                    }  // container password

                    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";
                    }

                    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";
                      }
                    }  // container advertisement-interval

                    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";
                      }
                    }  // container neighbor-cluster-id

                    leaf neighbor-graceful-restart {
                      type Bgp-nbrgr;
                      description
                        "TRUE to Enable graceful restart supportfor
neighbor.  FALSE to disable graceful restart
support for neighbor.";
                    }

                    leaf enforce-first-as {
                      type boolean;
                      description
                        "TRUE to enforce first AS; FALSE to not enforce
first AS.";
                    }

                    leaf idle-watch-time {
                      type uint32 {
                        range "30..1800";
                      }
                      units "second";
                      description
                        "Time to wait for deleteing IDLE state Dynamic
peer";
                    }

                    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 tcpmss

                    leaf session-open-mode {
                      type Bgp-tcp-mode;
                      default "either";
                      description
                        "TCP mode to be used to establish BGP session";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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";
                      }
                    }  // container tos

                    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";
                        }
                      }  // container update-in-filtering-message-buffers

                      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";
                      }
                    }  // container update-in-filtering

                    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";
                    }

                    container msg-log-out {
                      description
                        "Message log outbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-out

                    leaf suppress-all-capabilities {
                      type boolean;
                      description
                        "TRUE to suppress all capabilities. FALSE to not
suppress and to prevent inheritance from a
parent";
                    }

                    leaf max-peers {
                      type uint32 {
                        range "1..4096";
                      }
                      description
                        "Set Maximum Peers in Dynamic Range";
                    }

                    container ao-keychain {
                      description
                        "Set or disable AO based authentication";
                      leaf ao-keychain-disable {
                        type boolean;
                        description
                          "TRUE to prevent this entity from having AO
keychain based authentication even if the
parent has one.FALSE to enable AO keychain
based authentication";
                      }

                      leaf ao-keychain-name {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type string;
                        description
                          "Name of the AO keychain associated with this
neighbor";
                      }

                      leaf ao-include-tcp-options {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Include TCP options header with AO";
                      }

                      leaf ao-accept-mismatch-connection {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Accept new connections even though AO
mismatched";
                      }
                    }  // container ao-keychain

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    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";
                      }
                    }  // container receive-buffer-size

                    container msg-log-in {
                      description
                        "Message log inbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-in

                    leaf additional-paths-send-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    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";
                    }

                    container epe-peer-set-identities {
                      description
                        "Assign this neighbor to following peer-sets,
used for egress peer engineering";
                      list epe-peer-set-identity {
                        key "set-identity";
                        description
                          "Assign this neighbor to mentioned peer-set";
                        leaf set-identity {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identity of this EPE Peer-set";
                        }
                      }  // list epe-peer-set-identity
                    }  // container epe-peer-set-identities

                    leaf bfd-enable-modes {
                      type Bgp-bfd-enable-mode;
                      description
                        "Strict mode, Default mode or Disable to prevent
inheritance from a parent";
                    }

                    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";
                      }
                    }  // container send-buffer-size

                    leaf ttl-security {
                      type boolean;
                      description
                        "TRUE to enable BGP TTL Security.  FALSE to not
enable it and to prevent inheritance from a
parent";
                    }

                    leaf neighbor-graceful-restart-time {
                      type uint32 {
                        range "1..4095";
                      }
                      units "second";
                      default "120";
                      description
                        "Restart time advertised to neighbor";
                    }

                    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";
                      }
                    }  // container timers

                    leaf bfd-multiplier {
                      type uint32 {
                        range "2..16";
                      }
                      description
                        "Detection multiplier for BFD sessions created by
BGP";
                    }

                    leaf bfd-minimum-interval {
                      type uint32 {
                        range "3..30000";
                      }
                      units "millisecond";
                      description
                        "Hello interval for BFD sessions created by BGP";
                    }

                    leaf remote-as-list {
                      type string;
                      description
                        "Remote-as-list group name";
                    }

                    leaf labeled-unicast-equivalent-for-inbound-updates {
                      type boolean;
                      description
                        "TRUE to merge updates FALSE to not merge updates
and to prevent inheritance from a parent";
                    }

                    leaf additional-paths-receive-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    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 = false";
                        }
                        type string;
                        description
                          "Name of the keychain associated with neighbor";
                      }
                    }  // container keychain

                    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.";
                    }

                    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";
                    }

                    leaf update-source-interface {
                      type xr:Interface-name;
                      description
                        "Select an interface to configure";
                    }

                    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-local-preference

                      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";
                        }
                      }  // container graceful-maintenance-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";
                      }
                    }  // container graceful-maintenance
                  }  // list neighbor-prefix-length
                }  // container neighbors

                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";
                        }

                        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.";
                        }

                        leaf l2vpn-signalling {
                          type Bgp-signal;
                          description
                            "Disable signalling type on the peer";
                        }

                        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";
                        }

                        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.";
                        }

                        container aigp-cost-community {
                          description
                            "Send AIGP value in Cost Community. ";
                          leaf enable {
                            type boolean;
                            description
                              "TRUE to enable sending cost community, FALSE
otherwise ";
                          }

                          leaf cost-community-id {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type uint32 {
                              range "0..255";
                            }
                            description
                              "Cost Community ID";
                          }

                          leaf transitive {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type boolean;
                            description
                              "True to send transitive cost community FALSE
otherwise";
                          }

                          leaf cost-community-poi-type {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type Bgp-aigp-cfg-poi;
                            description
                              "Cost Community POI";
                          }
                        }  // container aigp-cost-community

                        leaf cluster-id-allow-equal {
                          type boolean;
                          description
                            "TRUE to disable cluster-id check for first id in
the cluster-id-list. FALSE to enable check for
all cluster-ids in the list.";
                        }

                        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";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v6

                        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";
                          }
                        }  // container advertise-disable

                        leaf send-multicast-attr {
                          type Bgp-send-mcast-attr-cfg;
                          description
                            "Config send multicast attribute for this
neighbor";
                        }

                        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";
                            }
                            mandatory true;
                            description
                              "Threshold value (%) at which to generate a
warning message.";
                          }

                          leaf warning-only {
                            type boolean;
                            mandatory true;
                            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";
                            }
                            mandatory true;
                            description
                              "Restart interval";
                          }

                          leaf discard-extra-paths {
                            type boolean;
                            mandatory true;
                            description
                              "Discard extra paths when limit is exceeded";
                          }
                        }  // container maximum-prefixes

                        container advertise-bridge-domain-imp-disable-v6 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v6

                        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.";
                          }
                        }  // container remove-private-as-entire-as-path-inbound

                        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.";
                        }

                        leaf advertise-local-labeled-route {
                          type dt1:Bgp-advertise-local-labeled-route-cfg;
                          description
                            "Enable/disable advertisement of routes with
local-label";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v4

                        leaf rpki-origin-as-validation-disable {
                          type empty;
                          description
                            "RPKI origin-AS validation disable";
                        }

                        container advertise-bridge-domain-imp-disable-v4 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v4

                        leaf flowspec-validation {
                          type Bgp-flowspec-validation-cfg;
                          description
                            "Config Flowspec validation for this neighbor";
                        }

                        container advertise-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-l2vpn-evpn

                        container advertise-local-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-local-l2vpn-evpn

                        leaf encapsulation-type {
                          type Bgp-af-encapsulation;
                          description
                            "Encapsulation type for this neighbor";
                        }

                        leaf rpki-bestpath-origin-as-allow-invalid {
                          type empty;
                          description
                            "RPKI bestpath origin-AS allow invalid";
                        }

                        leaf enforce-multiple-labels {
                          type boolean;
                          description
                            "TRUE to enforce multiple labels support.";
                        }

                        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";
                        }

                        leaf multipath {
                          type empty;
                          description
                            "Allow paths from this neighbor to be eligible
for selective multipath";
                        }

                        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";
                        }

                        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.";
                        }

                        leaf prefix-orf-policy {
                          type string;
                          description
                            "Prefix ORF policy name for incoming updates";
                        }

                        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)";
                          }
                        }  // container neighbor-af-long-lived-graceful-restart-stale-time

                        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";
                          }
                        }  // container site-of-origin

                        leaf update-out-orig-loop-chk-disable {
                          type empty;
                          description
                            "Enable/disable Originator loop check for this
neighbor-group/af-group";
                        }

                        leaf aigp {
                          type Bgp-aigp-cfg;
                          description
                            "Enable Accumulated IGP Metric for this neighbor.";
                        }

                        leaf aigp-send-med {
                          type Bgp-aigp-cfg;
                          description
                            "Enable/Disable sending AIGP in MED ";
                        }

                        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";
                          }
                        }  // container advertise-v6

                        leaf allow-as-in {
                          type uint32 {
                            range "1..10";
                          }
                          default "3";
                          description
                            "Allow as-path with my AS present in it";
                        }

                        leaf advertise-orf {
                          type Bgp-orf;
                          default "none";
                          description
                            "Advertise ORF capability to the peer";
                        }

                        leaf route-reflector-client {
                          type boolean;
                          description
                            "TRUE to configure as a route-reflector-client.
FALSE to prevent route-reflector-client from
being inherited.";
                        }

                        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.";
                        }

                        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";
                          }
                        }  // container advertise-local-v6

                        leaf srv6version4 {
                          type boolean;
                          description
                            "TRUE to enable SRv6 version 4,FALSE to disable
SRv6 version 4";
                        }

                        container slow-peer {
                          description
                            "Slow peer detection and update group splitting";
                          leaf detection {
                            when
                              "../static = 'true' or ../static = 'false'" {
                              description
                                "../Static = 'true' or ../Static = false";
                            }
                            type boolean;
                            description
                              "Detection enable or disable";
                          }

                          leaf static {
                            type boolean;
                            description
                              "Static or dynamic split";
                          }

                          leaf dynamic-type {
                            when
                              "../static = 'false'" {
                              description
                                "../Static = false";
                            }
                            type Bgp-upd-dynamic;
                            description
                              "Dynamic or Permanent";
                          }
                        }  // container slow-peer

                        leaf route-policy-in {
                          type string;
                          description
                            "Route policy name to apply to inbound routes";
                        }

                        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";
                          }
                        }  // container import

                        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.";
                          }
                        }  // container default-originate

                        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.";
                          }

                          leaf rpki-options {
                            type Bgp-rpki-soft-reconf-cfg;
                            default
                              "rpki-default-option";
                            description
                              "Rpki tested ordropped paths should be stored";
                          }
                        }  // container soft-reconfiguration

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v6

                        leaf default-weight {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Set default weight for routes from this
neighbor/neighbor-group/af-group";
                        }

                        leaf af-group {
                          type string;
                          description
                            "Inherit configuration for this address-family
from an AF-group";
                        }

                        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";
                          }
                        }  // container advertise-v4

                        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.";
                        }

                        leaf optimal-route-reflection-group {
                          type string;
                          description
                            "Name of the ORR group this neighbor is going to
be part of";
                        }

                        leaf accept-own {
                          type boolean;
                          description
                            "Handle self-originated routes with Accept-Own
community. Valid for following neighbor
address-families: VPNv4Unicast, VPNv6Unicast.";
                        }

                        leaf route-policy-out {
                          type string;
                          description
                            "Route policy name to apply to outbound routes";
                        }

                        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";
                          }
                        }  // container advertise-local-v4

                        leaf advertise-permanent-network {
                          type empty;
                          description
                            "Advertise Permanent Networks to the peer";
                        }

                        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 internal {
                            type boolean;
                            description
                              "TRUE if we need to remove private AS from
internal neighbors only. False to disable this
knob";
                          }

                          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.";
                          }
                        }  // container remove-private-as-entire-as-path

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v4
                      }  // list neighbor-group-af
                    }  // container neighbor-group-afs

                    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";
                    }

                    container local-address-sub-net {
                      description
                        "Local Address subnet of routing updates";
                      leaf local-addresss-subnet {
                        type inet:ip-address-no-zone;
                        description
                          "local address subnet ip address ";
                      }

                      leaf prefix-len {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "prefix length";
                      }
                    }  // container local-address-sub-net

                    leaf internal-vpn-client-ibgp-ce {
                      type boolean;
                      description
                        "TRUE to preserve the CE path attributes.FALSE to
override CE path attributes.";
                    }

                    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 = false";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "Local ip address for neighbor";
                      }
                    }  // container local-address

                    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";
                        }
                      }  // list bmp-activate
                    }  // container bmp-activates

                    container ebgp-multihop {
                      presence
                        "Contains mandatory nodes that used to set default values";
                      description
                        "Allow EBGP neighbors not on directly connected
networks";
                      leaf max-hop-count {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Maximum hop count";
                      }

                      leaf mpls-deactivation {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE to not enable MPLS and NULL rewrite.";
                      }
                    }  // container ebgp-multihop

                    leaf session-group-add-member {
                      type string;
                      description
                        "Inherit address-family independent config from a
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";
                    }

                    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";
                      }
                    }  // container remote-as

                    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";
                      }
                    }  // container local-as

                    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";
                    }

                    leaf shutdown {
                      type boolean;
                      description
                        "TRUE to shutdown this entity, FALSE to prevent
this entity from being shutdown even if the
parent is.";
                    }

                    leaf description {
                      type string;
                      description
                        "Up to 80 characters describing this neighbor";
                    }

                    leaf suppress-extended-nexthop-encoding-capability {
                      type boolean;
                      description
                        "TRUE to suppress Extended Nexthop encoding
capability. FALSE to not suppress and to prevent
inheritance from a parent";
                    }

                    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 = false";
                        }
                        type xr:Proprietary-password;
                        description
                          "The neighbor password.  Leave unspecified when
disabling the password.";
                      }
                    }  // container password

                    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";
                    }

                    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";
                      }
                    }  // container advertisement-interval

                    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";
                      }
                    }  // container neighbor-cluster-id

                    leaf neighbor-graceful-restart {
                      type Bgp-nbrgr;
                      description
                        "TRUE to Enable graceful restart supportfor
neighbor.  FALSE to disable graceful restart
support for neighbor.";
                    }

                    leaf enforce-first-as {
                      type boolean;
                      description
                        "TRUE to enforce first AS; FALSE to not enforce
first AS.";
                    }

                    leaf idle-watch-time {
                      type uint32 {
                        range "30..1800";
                      }
                      units "second";
                      description
                        "Time to wait for deleteing IDLE state Dynamic
peer";
                    }

                    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 tcpmss

                    leaf session-open-mode {
                      type Bgp-tcp-mode;
                      default "either";
                      description
                        "TCP mode to be used to establish BGP session";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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";
                      }
                    }  // container tos

                    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";
                        }
                      }  // container update-in-filtering-message-buffers

                      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";
                      }
                    }  // container update-in-filtering

                    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";
                    }

                    container msg-log-out {
                      description
                        "Message log outbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-out

                    leaf suppress-all-capabilities {
                      type boolean;
                      description
                        "TRUE to suppress all capabilities. FALSE to not
suppress and to prevent inheritance from a
parent";
                    }

                    leaf max-peers {
                      type uint32 {
                        range "1..4096";
                      }
                      description
                        "Set Maximum Peers in Dynamic Range";
                    }

                    container ao-keychain {
                      description
                        "Set or disable AO based authentication";
                      leaf ao-keychain-disable {
                        type boolean;
                        description
                          "TRUE to prevent this entity from having AO
keychain based authentication even if the
parent has one.FALSE to enable AO keychain
based authentication";
                      }

                      leaf ao-keychain-name {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type string;
                        description
                          "Name of the AO keychain associated with this
neighbor";
                      }

                      leaf ao-include-tcp-options {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Include TCP options header with AO";
                      }

                      leaf ao-accept-mismatch-connection {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Accept new connections even though AO
mismatched";
                      }
                    }  // container ao-keychain

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    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";
                      }
                    }  // container receive-buffer-size

                    container msg-log-in {
                      description
                        "Message log inbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-in

                    leaf additional-paths-send-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    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";
                    }

                    container epe-peer-set-identities {
                      description
                        "Assign this neighbor to following peer-sets,
used for egress peer engineering";
                      list epe-peer-set-identity {
                        key "set-identity";
                        description
                          "Assign this neighbor to mentioned peer-set";
                        leaf set-identity {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identity of this EPE Peer-set";
                        }
                      }  // list epe-peer-set-identity
                    }  // container epe-peer-set-identities

                    leaf bfd-enable-modes {
                      type Bgp-bfd-enable-mode;
                      description
                        "Strict mode, Default mode or Disable to prevent
inheritance from a parent";
                    }

                    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";
                      }
                    }  // container send-buffer-size

                    leaf ttl-security {
                      type boolean;
                      description
                        "TRUE to enable BGP TTL Security.  FALSE to not
enable it and to prevent inheritance from a
parent";
                    }

                    leaf neighbor-graceful-restart-time {
                      type uint32 {
                        range "1..4095";
                      }
                      units "second";
                      default "120";
                      description
                        "Restart time advertised to neighbor";
                    }

                    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";
                      }
                    }  // container timers

                    leaf bfd-multiplier {
                      type uint32 {
                        range "2..16";
                      }
                      description
                        "Detection multiplier for BFD sessions created by
BGP";
                    }

                    leaf bfd-minimum-interval {
                      type uint32 {
                        range "3..30000";
                      }
                      units "millisecond";
                      description
                        "Hello interval for BFD sessions created by BGP";
                    }

                    leaf remote-as-list {
                      type string;
                      description
                        "Remote-as-list group name";
                    }

                    leaf labeled-unicast-equivalent-for-inbound-updates {
                      type boolean;
                      description
                        "TRUE to merge updates FALSE to not merge updates
and to prevent inheritance from a parent";
                    }

                    leaf additional-paths-receive-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    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 = false";
                        }
                        type string;
                        description
                          "Name of the keychain associated with neighbor";
                      }
                    }  // container keychain

                    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.";
                    }

                    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";
                    }

                    leaf update-source-interface {
                      type xr:Interface-name;
                      description
                        "Select an interface to configure";
                    }

                    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.";
                    }

                    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-local-preference

                      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";
                        }
                      }  // container graceful-maintenance-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";
                      }
                    }  // container graceful-maintenance
                  }  // list neighbor-group
                }  // container neighbor-groups

                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";
                        }

                        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.";
                        }

                        leaf l2vpn-signalling {
                          type Bgp-signal;
                          description
                            "Disable signalling type on the peer";
                        }

                        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";
                        }

                        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.";
                        }

                        container aigp-cost-community {
                          description
                            "Send AIGP value in Cost Community. ";
                          leaf enable {
                            type boolean;
                            description
                              "TRUE to enable sending cost community, FALSE
otherwise ";
                          }

                          leaf cost-community-id {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type uint32 {
                              range "0..255";
                            }
                            description
                              "Cost Community ID";
                          }

                          leaf transitive {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type boolean;
                            description
                              "True to send transitive cost community FALSE
otherwise";
                          }

                          leaf cost-community-poi-type {
                            when
                              "../enable = 'true'" {
                              description
                                "../Enable = 'true'";
                            }
                            type Bgp-aigp-cfg-poi;
                            description
                              "Cost Community POI";
                          }
                        }  // container aigp-cost-community

                        leaf cluster-id-allow-equal {
                          type boolean;
                          description
                            "TRUE to disable cluster-id check for first id in
the cluster-id-list. FALSE to enable check for
all cluster-ids in the list.";
                        }

                        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";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v6

                        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";
                          }
                        }  // container advertise-disable

                        leaf send-multicast-attr {
                          type Bgp-send-mcast-attr-cfg;
                          description
                            "Config send multicast attribute for this
neighbor";
                        }

                        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";
                            }
                            mandatory true;
                            description
                              "Threshold value (%) at which to generate a
warning message.";
                          }

                          leaf warning-only {
                            type boolean;
                            mandatory true;
                            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";
                            }
                            mandatory true;
                            description
                              "Restart interval";
                          }

                          leaf discard-extra-paths {
                            type boolean;
                            mandatory true;
                            description
                              "Discard extra paths when limit is exceeded";
                          }
                        }  // container maximum-prefixes

                        container advertise-bridge-domain-imp-disable-v6 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v6

                        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.";
                          }
                        }  // container remove-private-as-entire-as-path-inbound

                        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.";
                        }

                        leaf advertise-local-labeled-route {
                          type dt1:Bgp-advertise-local-labeled-route-cfg;
                          description
                            "Enable/disable advertisement of routes with
local-label";
                        }

                        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";
                          }
                        }  // container advertise-def-imp-disable-v4

                        leaf rpki-origin-as-validation-disable {
                          type empty;
                          description
                            "RPKI origin-AS validation disable";
                        }

                        container advertise-bridge-domain-imp-disable-v4 {
                          description
                            "Disable Advertise Of VRF EVPN Extranet Imported
Routes";
                          leaf af-name {
                            type dt1:Bgp-address-family;
                            must
                              "../adv-option and ../rt-type";
                            description
                              "Address family";
                          }

                          leaf adv-option {
                            type Bgp-reorg-opt;
                            must
                              "../af-name and ../rt-type";
                            description
                              "Advertise option";
                          }

                          leaf rt-type {
                            type Bgp-adv-rt;
                            must
                              "../af-name and ../adv-option";
                            description
                              "RT type";
                          }
                        }  // container advertise-bridge-domain-imp-disable-v4

                        leaf flowspec-validation {
                          type Bgp-flowspec-validation-cfg;
                          description
                            "Config Flowspec validation for this neighbor";
                        }

                        container advertise-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-l2vpn-evpn

                        container advertise-local-l2vpn-evpn {
                          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";
                          }
                        }  // container advertise-local-l2vpn-evpn

                        leaf encapsulation-type {
                          type Bgp-af-encapsulation;
                          description
                            "Encapsulation type for this neighbor";
                        }

                        leaf rpki-bestpath-origin-as-allow-invalid {
                          type empty;
                          description
                            "RPKI bestpath origin-AS allow invalid";
                        }

                        leaf enforce-multiple-labels {
                          type boolean;
                          description
                            "TRUE to enforce multiple labels support.";
                        }

                        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";
                        }

                        leaf multipath {
                          type empty;
                          description
                            "Allow paths from this neighbor to be eligible
for selective multipath";
                        }

                        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";
                        }

                        leaf prefix-orf-policy {
                          type string;
                          description
                            "Prefix ORF policy name for incoming updates";
                        }

                        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)";
                          }
                        }  // container neighbor-af-long-lived-graceful-restart-stale-time

                        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";
                          }
                        }  // container site-of-origin

                        leaf update-out-orig-loop-chk-disable {
                          type empty;
                          description
                            "Enable/disable Originator loop check for this
neighbor-group/af-group";
                        }

                        leaf aigp {
                          type Bgp-aigp-cfg;
                          description
                            "Enable Accumulated IGP Metric for this neighbor.";
                        }

                        leaf aigp-send-med {
                          type Bgp-aigp-cfg;
                          description
                            "Enable/Disable sending AIGP in MED ";
                        }

                        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";
                          }
                        }  // container advertise-v6

                        leaf allow-as-in {
                          type uint32 {
                            range "1..10";
                          }
                          default "3";
                          description
                            "Allow as-path with my AS present in it";
                        }

                        leaf advertise-orf {
                          type Bgp-orf;
                          default "none";
                          description
                            "Advertise ORF capability to the peer";
                        }

                        leaf route-reflector-client {
                          type boolean;
                          description
                            "TRUE to configure as a route-reflector-client.
FALSE to prevent route-reflector-client from
being inherited.";
                        }

                        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.";
                        }

                        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";
                          }
                        }  // container advertise-local-v6

                        leaf srv6version4 {
                          type boolean;
                          description
                            "TRUE to enable SRv6 version 4,FALSE to disable
SRv6 version 4";
                        }

                        container slow-peer {
                          description
                            "Slow peer detection and update group splitting";
                          leaf detection {
                            when
                              "../static = 'true' or ../static = 'false'" {
                              description
                                "../Static = 'true' or ../Static = false";
                            }
                            type boolean;
                            description
                              "Detection enable or disable";
                          }

                          leaf static {
                            type boolean;
                            description
                              "Static or dynamic split";
                          }

                          leaf dynamic-type {
                            when
                              "../static = 'false'" {
                              description
                                "../Static = false";
                            }
                            type Bgp-upd-dynamic;
                            description
                              "Dynamic or Permanent";
                          }
                        }  // container slow-peer

                        leaf route-policy-in {
                          type string;
                          description
                            "Route policy name to apply to inbound routes";
                        }

                        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";
                          }
                        }  // container import

                        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.";
                          }
                        }  // container default-originate

                        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.";
                          }

                          leaf rpki-options {
                            type Bgp-rpki-soft-reconf-cfg;
                            default
                              "rpki-default-option";
                            description
                              "Rpki tested ordropped paths should be stored";
                          }
                        }  // container soft-reconfiguration

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v6

                        leaf default-weight {
                          type uint32 {
                            range "0..65535";
                          }
                          description
                            "Set default weight for routes from this
neighbor/neighbor-group/af-group";
                        }

                        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";
                          }
                        }  // container advertise-v4

                        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.";
                        }

                        leaf optimal-route-reflection-group {
                          type string;
                          description
                            "Name of the ORR group this neighbor is going to
be part of";
                        }

                        leaf accept-own {
                          type boolean;
                          description
                            "Handle self-originated routes with Accept-Own
community. Valid for following neighbor
address-families: VPNv4Unicast, VPNv6Unicast.";
                        }

                        leaf route-policy-out {
                          type string;
                          description
                            "Route policy name to apply to outbound routes";
                        }

                        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";
                          }
                        }  // container advertise-local-v4

                        leaf advertise-permanent-network {
                          type empty;
                          description
                            "Advertise Permanent Networks to the peer";
                        }

                        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 internal {
                            type boolean;
                            description
                              "TRUE if we need to remove private AS from
internal neighbors only. False to disable this
knob";
                          }

                          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.";
                          }
                        }  // container remove-private-as-entire-as-path

                        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";
                          }
                        }  // container advertise-vrf-imp-disable-v4
                      }  // list af-group-af
                    }  // container af-group-afs

                    leaf af-group-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "BGP AF group name";
                    }
                  }  // list af-group
                }  // container af-groups

                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";
                    }

                    container local-address-sub-net {
                      description
                        "Local Address subnet of routing updates";
                      leaf local-addresss-subnet {
                        type inet:ip-address-no-zone;
                        description
                          "local address subnet ip address ";
                      }

                      leaf prefix-len {
                        type uint32 {
                          range "0..128";
                        }
                        description
                          "prefix length";
                      }
                    }  // container local-address-sub-net

                    leaf internal-vpn-client-ibgp-ce {
                      type boolean;
                      description
                        "TRUE to preserve the CE path attributes.FALSE to
override CE path attributes.";
                    }

                    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 = false";
                        }
                        type inet:ip-address-no-zone;
                        description
                          "Local ip address for neighbor";
                      }
                    }  // container local-address

                    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";
                        }
                      }  // list bmp-activate
                    }  // container bmp-activates

                    container ebgp-multihop {
                      presence
                        "Contains mandatory nodes that used to set default values";
                      description
                        "Allow EBGP neighbors not on directly connected
networks";
                      leaf max-hop-count {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Maximum hop count";
                      }

                      leaf mpls-deactivation {
                        type boolean;
                        mandatory true;
                        description
                          "TRUE to not enable MPLS and NULL rewrite.";
                      }
                    }  // container ebgp-multihop

                    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";
                    }

                    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";
                      }
                    }  // container remote-as

                    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";
                      }
                    }  // container local-as

                    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";
                    }

                    leaf shutdown {
                      type boolean;
                      description
                        "TRUE to shutdown this entity, FALSE to prevent
this entity from being shutdown even if the
parent is.";
                    }

                    leaf description {
                      type string;
                      description
                        "Up to 80 characters describing this neighbor";
                    }

                    leaf suppress-extended-nexthop-encoding-capability {
                      type boolean;
                      description
                        "TRUE to suppress Extended Nexthop encoding
capability. FALSE to not suppress and to prevent
inheritance from a parent";
                    }

                    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 = false";
                        }
                        type xr:Proprietary-password;
                        description
                          "The neighbor password.  Leave unspecified when
disabling the password.";
                      }
                    }  // container password

                    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";
                    }

                    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";
                      }
                    }  // container advertisement-interval

                    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";
                      }
                    }  // container neighbor-cluster-id

                    leaf neighbor-graceful-restart {
                      type Bgp-nbrgr;
                      description
                        "TRUE to Enable graceful restart supportfor
neighbor.  FALSE to disable graceful restart
support for neighbor.";
                    }

                    leaf enforce-first-as {
                      type boolean;
                      description
                        "TRUE to enforce first AS; FALSE to not enforce
first AS.";
                    }

                    leaf idle-watch-time {
                      type uint32 {
                        range "30..1800";
                      }
                      units "second";
                      description
                        "Time to wait for deleteing IDLE state Dynamic
peer";
                    }

                    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 tcpmss

                    leaf session-open-mode {
                      type Bgp-tcp-mode;
                      default "either";
                      description
                        "TCP mode to be used to establish BGP session";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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";
                      }
                    }  // container tos

                    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";
                        }
                      }  // container update-in-filtering-message-buffers

                      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";
                      }
                    }  // container update-in-filtering

                    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";
                    }

                    container msg-log-out {
                      description
                        "Message log outbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-out

                    leaf suppress-all-capabilities {
                      type boolean;
                      description
                        "TRUE to suppress all capabilities. FALSE to not
suppress and to prevent inheritance from a
parent";
                    }

                    leaf max-peers {
                      type uint32 {
                        range "1..4096";
                      }
                      description
                        "Set Maximum Peers in Dynamic Range";
                    }

                    container ao-keychain {
                      description
                        "Set or disable AO based authentication";
                      leaf ao-keychain-disable {
                        type boolean;
                        description
                          "TRUE to prevent this entity from having AO
keychain based authentication even if the
parent has one.FALSE to enable AO keychain
based authentication";
                      }

                      leaf ao-keychain-name {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type string;
                        description
                          "Name of the AO keychain associated with this
neighbor";
                      }

                      leaf ao-include-tcp-options {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Include TCP options header with AO";
                      }

                      leaf ao-accept-mismatch-connection {
                        when
                          "../ao-keychain-disable = 'false'" {
                          description
                            "../AOKeychainDisable = false";
                        }
                        type boolean;
                        description
                          "Accept new connections even though AO
mismatched";
                      }
                    }  // container ao-keychain

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    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";
                      }
                    }  // container receive-buffer-size

                    container msg-log-in {
                      description
                        "Message log inbound";
                      leaf msg-buf-count {
                        type uint32 {
                          range "1..500";
                        }
                        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";
                      }
                    }  // container msg-log-in

                    leaf additional-paths-send-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    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";
                    }

                    container epe-peer-set-identities {
                      description
                        "Assign this neighbor to following peer-sets,
used for egress peer engineering";
                      list epe-peer-set-identity {
                        key "set-identity";
                        description
                          "Assign this neighbor to mentioned peer-set";
                        leaf set-identity {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identity of this EPE Peer-set";
                        }
                      }  // list epe-peer-set-identity
                    }  // container epe-peer-set-identities

                    leaf bfd-enable-modes {
                      type Bgp-bfd-enable-mode;
                      description
                        "Strict mode, Default mode or Disable to prevent
inheritance from a parent";
                    }

                    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";
                      }
                    }  // container send-buffer-size

                    leaf ttl-security {
                      type boolean;
                      description
                        "TRUE to enable BGP TTL Security.  FALSE to not
enable it and to prevent inheritance from a
parent";
                    }

                    leaf neighbor-graceful-restart-time {
                      type uint32 {
                        range "1..4095";
                      }
                      units "second";
                      default "120";
                      description
                        "Restart time advertised to neighbor";
                    }

                    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";
                      }
                    }  // container timers

                    leaf bfd-multiplier {
                      type uint32 {
                        range "2..16";
                      }
                      description
                        "Detection multiplier for BFD sessions created by
BGP";
                    }

                    leaf bfd-minimum-interval {
                      type uint32 {
                        range "3..30000";
                      }
                      units "millisecond";
                      description
                        "Hello interval for BFD sessions created by BGP";
                    }

                    leaf remote-as-list {
                      type string;
                      description
                        "Remote-as-list group name";
                    }

                    leaf labeled-unicast-equivalent-for-inbound-updates {
                      type boolean;
                      description
                        "TRUE to merge updates FALSE to not merge updates
and to prevent inheritance from a parent";
                    }

                    leaf additional-paths-receive-capability {
                      type dt1:Bgp-nbr-cap-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    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 = false";
                        }
                        type string;
                        description
                          "Name of the keychain associated with neighbor";
                      }
                    }  // container keychain

                    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.";
                    }

                    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";
                    }

                    leaf update-source-interface {
                      type xr:Interface-name;
                      description
                        "Select an interface to configure";
                    }

                    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.";
                    }

                    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-local-preference

                      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";
                        }
                      }  // container graceful-maintenance-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";
                      }
                    }  // container graceful-maintenance
                  }  // list session-group
                }  // container session-groups
              }  // container bgp-entity

              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 cluster-id

                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 write-limit

                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;
                    must "../delay";
                    default "false";
                    description
                      "Set to TRUE to disable keepalive trigger
                     bestpath and delay is enforced.";
                  }
                }  // container update-delay

                container optimal-route-reflection-group-global-afis {
                  description
                    "Global table of multiple ORR groups";
                  list optimal-route-reflection-group-global-afi {
                    key "afi";
                    description
                      "The afi of the ORR group";
                    leaf afi {
                      type Bgp-orrafi;
                      description
                        "The AFI corresponds to root address";
                    }

                    list optimal-route-reflection-group-global {
                      key "group-name";
                      description
                        "Global Optimal Route Reflector group.
                       Each such group is equivalent to an IGP
                       area";
                      leaf group-name {
                        type xr:Cisco-ios-xr-string;
                        description
                          "Name of the ORR group";
                      }

                      leaf primary-root-address {
                        type inet:ip-address-no-zone;
                        description
                          "Primary Root for the ORR group";
                      }

                      leaf secondary-root-address {
                        type inet:ip-address-no-zone;
                        description
                          "Secondary Root for the ORR group";
                      }

                      leaf tertiary-root-address {
                        type inet:ip-address-no-zone;
                        description
                          "Tertiary Root for the ORR group";
                      }
                    }  // list optimal-route-reflection-group-global
                  }  // list optimal-route-reflection-group-global-afi
                }  // container optimal-route-reflection-group-global-afis

                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";
                      }
                    }  // list peer
                  }  // container peers

                  leaf enable {
                    type empty;
                    description
                      "AS League creation";
                  }
                }  // container as-league

                container rpki-servers {
                  description
                    "RPKI server configuration";
                  list rpki-server {
                    key "server";
                    description
                      "RPKI server configuration";
                    container bindsrc {
                      description
                        "RPKI server transport bind source";
                      leaf bindsrc-type {
                        type Bgp-rpki-binssrc;
                        description
                          "Bind source type";
                      }

                      leaf bind-src {
                        type string;
                        description
                          "server bind source interface";
                      }
                    }  // container bindsrc

                    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";
                      }
                    }  // container transport

                    leaf enable {
                      type empty;
                      description
                        "RPKI server configuration";
                    }

                    leaf shutdown {
                      type empty;
                      description
                        "RPKI server shutdown";
                    }

                    leaf password {
                      type xr:Proprietary-password;
                      description
                        "RPKI server password";
                    }

                    leaf response-time {
                      type Bgp-rpki-time-config;
                      units "second";
                      description
                        "RPKI server response-time(15-3600
                       seconds) or off";
                    }

                    leaf username {
                      type string;
                      description
                        "RPKI server username";
                    }

                    leaf refresh-time {
                      type Bgp-rpki-time-config;
                      units "second";
                      description
                        "RPKI server refresh-time(15-3600 seconds)
                       or off";
                    }

                    leaf purge-time {
                      type uint32 {
                        range "30..65535";
                      }
                      units "second";
                      description
                        "RPKI server purge-time (in seconds)";
                    }

                    leaf server {
                      type xr:Cisco-ios-xr-string;
                      description
                        "Server address (opaque string)";
                    }
                  }  // list rpki-server
                }  // container rpki-servers

                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";
                        }
                      }  // list as
                    }  // container ases

                    leaf enable {
                      type empty;
                      description
                        "AS-List group creation";
                    }

                    leaf as-list-group-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "Group name";
                    }
                  }  // list as-list-group
                }  // container as-list-groups

                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 limits

                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-domain

                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";
                    }
                  }  // list confederation-peer-as
                }  // container confederation-peer-ases

                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";
                        }
                      }  // list attribute-filter
                    }  // container attribute-filters

                    leaf enable {
                      type empty;
                      description
                        "Attribute-filter group creation";
                    }

                    leaf attribute-filter-group-name {
                      type xr:Cisco-ios-xr-string;
                      description
                        "Group name";
                    }
                  }  // list attribute-filter-group
                }  // container attribute-filter-groups

                container segment-routing-global {
                  description
                    "Segment-routing Gbl Configurations";
                  container srv6-global {
                    description
                      "SRv6 Configurations";
                    leaf enable {
                      type empty;
                      description
                        "Enable SRv6 configuration submode";
                    }

                    leaf locator-name {
                      type string;
                      description
                        "Configure Locator name for SID allocation";
                    }
                  }  // container srv6-global
                }  // container segment-routing-global

                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. 00 for all
                           options together";
                        }

                        leaf multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // list isis-route
                    }  // container isis-routes

                    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 domain-distinguisher

                    container vrf-all {
                      description
                        "Configurations to be inherited to all
                       vrfs";
                      container segment-routing-vrf-all {
                        description
                          "Segment-routing Vrf All Configurations";
                        container srv6-vrf-all {
                          description
                            "SRv6 Configurations";
                          leaf enable {
                            type empty;
                            description
                              "Enable SRv6 configuration submode";
                          }

                          leaf srv6sid-allocation-mode {
                            type string;
                            description
                              "SID allocation mode: per-ce  Set per
                             CE SID mode,per-vrf Set per VRF SID
                             mode";
                          }

                          leaf locator-name {
                            type string;
                            description
                              "Configure Locator name for SID
                             allocation";
                          }
                        }  // container srv6-vrf-all
                      }  // container segment-routing-vrf-all

                      container label-mode {
                        presence
                          "Contains mandatory nodes that used to set default values";
                        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";
                        }
                      }  // container label-mode

                      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 vrf-all

                    container export-vrf-allow {
                      description
                        "Allow export/leak to Vrf based on
                       path-type";
                      leaf export-allow-backup {
                        type boolean;
                        description
                          "TRUE Enable Leaking(export) of backup
                         path, FALSE Disable Leaking(export) of
                         backup path";
                      }
                    }  // container export-vrf-allow

                    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 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";
                          }
                        }  // list ipv4-address
                      }  // list disable-cluster-client-to-client-rr
                    }  // container disable-cluster-client-to-client-rrs

                    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 label-delay

                    container ebgp {
                      presence
                        "Indicates a ebgp node is configured.";
                      description
                        "Use eBGP multipaths";
                      leaf paths-value {
                        type uint32 {
                          range "2..128";
                        }
                        mandatory true;
                        description
                          "Number of paths";
                      }

                      leaf unequal-cost {
                        type boolean;
                        mandatory true;
                        description "UNUSED";
                      }

                      leaf selective {
                        type boolean;
                        mandatory true;
                        description
                          "Allow multipaths only from marked
                         neighbors";
                      }

                      leaf order-by-igp-metric {
                        type boolean;
                        mandatory true;
                        description
                          "Order candidate multipaths by IGP metric";
                      }
                    }  // container ebgp

                    container eibgp {
                      presence
                        "Indicates a eibgp node is configured.";
                      description
                        "Use eiBGP multipaths";
                      leaf paths-value {
                        type uint32 {
                          range "2..128";
                        }
                        mandatory true;
                        description
                          "Number of paths";
                      }

                      leaf unequal-cost {
                        type boolean;
                        mandatory true;
                        description "UNUSED";
                      }

                      leaf selective {
                        type boolean;
                        mandatory true;
                        description
                          "Allow multipaths only from marked
                         neighbors";
                      }

                      leaf order-by-igp-metric {
                        type boolean;
                        mandatory true;
                        description
                          "Order candidate multipaths by IGP metric";
                      }
                    }  // container eibgp

                    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 retain-rt

                    container ibgp {
                      presence
                        "Indicates a ibgp node is configured.";
                      description
                        "Use iBGP multipaths";
                      leaf paths-value {
                        type uint32 {
                          range "2..128";
                        }
                        mandatory true;
                        description
                          "Number of paths";
                      }

                      leaf unequal-cost {
                        type boolean;
                        mandatory true;
                        description
                          "Allow multipaths to have different IGP
                         metrics";
                      }

                      leaf selective {
                        type boolean;
                        mandatory true;
                        description
                          "Allow multipaths only from marked
                         neighbors";
                      }

                      leaf order-by-igp-metric {
                        type boolean;
                        mandatory true;
                        description
                          "Order candidate multipaths by IGP metric";
                      }
                    }  // container ibgp

                    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";
                      }
                    }  // container import-delay

                    container peer-set-ids {
                      description
                        "Table of Peer Set Identifiers";
                      list peer-set-id {
                        key "peer-set";
                        description
                          "Create Identifier for a Peer Set";
                        leaf peer-set-sid {
                          type uint32 {
                            range
                              "0..1033575";
                          }
                          description
                            "Peer Set Label Index off SRLB to be
                           assigned to this Peer Set";
                        }

                        leaf enable {
                          type empty;
                          description
                            "Peer Set Identifier creation";
                        }

                        leaf peer-set {
                          type uint32 {
                            range "1..255";
                          }
                          description
                            "Identifier value";
                        }
                      }  // list peer-set-id
                    }  // container peer-set-ids

                    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 option-basbr-only {
                      type empty;
                      description
                        "This option makes the router an Option B
                       ASBR for EVPN. Its assumed no DCI configs
                       are present";
                    }

                    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 implicit-import {
                      type empty;
                      description
                        "Implicit import configuration";
                    }

                    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 source-route-target-policy {
                      type string;
                      description
                        "Route policy name to apply to configure
                       source route-target";
                    }

                    leaf rpki-origin-as-validation-disable {
                      type empty;
                      description
                        "RPKI origin-AS validation disable";
                    }

                    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 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 optimal-route-reflection-default-bestpath {
                      type boolean;
                      description
                        "Enable fallback to default table's
                       bestpath when ORR bestpath is not
                       available";
                    }

                    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 prefix-sid-map {
                      type empty;
                      description
                        "Retrieve prefix sid mapping from SRMS";
                    }

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

                    leaf rpki-origin-as-validation-enable {
                      type empty;
                      description
                        "RPKI origin-AS validation enable";
                    }

                    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";
                        }
                      }  // list aggregate-address
                    }  // container aggregate-addresses

                    leaf dynamic-med-interval {
                      type uint32 {
                        range "0..10";
                      }
                      units "minute";
                      default "10";
                      description
                        "Update generation delay (in minutes) after a MED
change";
                    }

                    leaf event-prefix-route-policy {
                      type string;
                      description
                        "Route Policy to mark prefixes to be traced";
                    }

                    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.";
                      }
                    }  // container dampening

                    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
.";
                    }

                    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 multipath {
                        type boolean;
                        description
                          "Specify if Multipath, default is FALSE";
                      }
                    }  // container rip-routes

                    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";
                      }

                      leaf multipath {
                        type boolean;
                        description
                          "Specify if Multipath, default is FALSE";
                      }
                    }  // container lisp-routes

                    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 multipath {
                        type boolean;
                        description
                          "Specify if Multipath, default is FALSE";
                      }
                    }  // container static-routes

                    container distance {
                      presence
                        "Indicates a distance node is configured.";
                      description
                        "Define an administrative distance";
                      leaf external-routes {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Distance for routes external to the AS";
                      }

                      leaf internal-routes {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Distance for routes internal to the AS";
                      }

                      leaf local-routes {
                        type uint32 {
                          range "1..255";
                        }
                        mandatory true;
                        description
                          "Distance for local routes";
                      }
                    }  // container distance

                    leaf table-policy {
                      type string;
                      description
                        "Configure policy for installation of routes to
RIB";
                    }

                    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 multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // list application-route
                    }  // container application-routes

                    leaf attribute-download {
                      type empty;
                      description
                        "Attribute download configuration";
                    }

                    container label-mode {
                      presence
                        "enable 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";
                      }
                    }  // container label-mode

                    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.";
                        }

                        leaf multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // list eigrp-route
                    }  // container eigrp-routes

                    container best-external {
                      description
                        "Enable Bestexternal config";
                      leaf enable {
                        type boolean;
                        description
                          "TRUE to enable BE FALSE to disable BE
inheritance from a parent";
                      }

                      leaf labeled-unicast {
                        type boolean;
                        description
                          "Limit Best-External to Labeled-Unicast";
                      }
                    }  // container best-external

                    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";
                        }

                        leaf multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // list sourced-network
                    }  // container sourced-networks

                    leaf rpki-origin-as-validity-signal-ibgp {
                      type empty;
                      description
                        "RPKI origin-AS validity signal ibgp";
                    }

                    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 multipath {
                        type boolean;
                        description
                          "Specify if Multipath, default is FALSE";
                      }
                    }  // container connected-routes

                    leaf additional-paths-receive {
                      type dt1:Bgp-af-additional-paths-cfg;
                      description
                        "Advertise additional paths Receive capability";
                    }

                    leaf permanent-network {
                      type string;
                      description
                        "Route policy for permanent networks";
                    }

                    leaf rpki-bestpath-use-origin-as-validity {
                      type empty;
                      description
                        "RPKI bestpath use origin-AS validity";
                    }

                    container allocate-label {
                      presence
                        "enable 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";
                      }

                      leaf un-labeled-path {
                        type boolean;
                        must
                          "../all or ../route-policy-name";
                        description
                          "Allocate label for unlabeled paths too";
                      }
                    }  // container allocate-label

                    container additional-paths-selection {
                      description
                        "Configure additional paths selection";
                      leaf selection {
                        type dt1:Bgp-af-additional-paths-cfg;
                        description
                          "Enable/disable selection ";
                      }

                      leaf route-policy-name {
                        type string;
                        description
                          "Route policy for selection";
                      }
                    }  // container additional-paths-selection

                    leaf rpki-bestpath-origin-as-allow-invalid {
                      type empty;
                      description
                        "RPKI bestpath origin-AS allow invalid";
                    }

                    leaf next-hop-resolution-prefix-length-minimum {
                      type uint32 {
                        range "0..128";
                      }
                      default "0";
                      description
                        "Minimum prefix-length for nexthop resolution";
                    }

                    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";
                    }

                    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.";
                        }

                        leaf multipath {
                          type boolean;
                          description
                            "Specify if Multipath, default is FALSE";
                        }
                      }  // list ospf-route
                    }  // container ospf-routes

                    leaf additional-paths-send {
                      type dt1:Bgp-af-additional-paths-cfg;
                      description
                        "Advertise additional paths Send capability";
                    }

                    container optimal-route-reflection-group-applies {
                      description
                        "Table of multiple ORR groups";
                      list optimal-route-reflection-group-apply {
                        key "group-name";
                        description
                          "Optimal Route Reffelction group. Each such
group is equivalent to an IGP area";
                        leaf group-name {
                          type xr:Cisco-ios-xr-string;
                          description
                            "Name of the ORR group";
                        }
                      }  // list optimal-route-reflection-group-apply
                    }  // container optimal-route-reflection-group-applies

                    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";
                    }

                    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 multipath {
                        type boolean;
                        description
                          "Specify if Multipath, default is FALSE";
                      }
                    }  // container mobile-routes

                    leaf disable-as-path-loop-check {
                      type empty;
                      description
                        "Disable outbound AS Path loop check";
                    }

                    leaf next-hop-resolution-prefix-length-minimum-ipv6 {
                      type uint32 {
                        range "0..128";
                      }
                      default "0";
                      description
                        "Minimum prefix-length for nexthop resolution";
                    }

                    container optimal-route-reflection-groups {
                      description
                        "Table of multiple ORR Groups";
                      list optimal-route-reflection-group {
                        key "group-name";
                        description
                          "Optimal Route Reffelction group. Each such
group is equivalent to an IGP area";
                        leaf group-name {
                          type xr:Cisco-ios-xr-string;
                          description
                            "Name of the ORR group";
                        }

                        leaf primary-root-address {
                          type inet:ip-address-no-zone;
                          description
                            "Primary Root for the ORR group";
                        }

                        leaf secondary-root-address {
                          type inet:ip-address-no-zone;
                          description
                            "Secondary Root for the ORR group";
                        }

                        leaf tertiary-root-address {
                          type inet:ip-address-no-zone;
                          description
                            "Tertiary Root for the ORR group";
                        }
                      }  // list optimal-route-reflection-group
                    }  // container optimal-route-reflection-groups

                    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 multipath {
                        type boolean;
                        description
                          "Specify if Multipath, default is FALSE";
                      }
                    }  // container subscriber-routes

                    container segment-routing {
                      description
                        "Segment-routing Configurations";
                      container srv6 {
                        description
                          "SRv6 Configurations";
                        leaf enable {
                          type empty;
                          description
                            "Enable SRv6 configuration submode";
                        }

                        leaf srv6sid-allocation-mode {
                          type string;
                          description
                            "SID allocation mode: per-ce  Set per CE SID
mode,per-vrf Set per VRF SID mode";
                        }

                        leaf locator-name {
                          type string;
                          description
                            "Configure Locator name for SID allocation";
                        }
                      }  // container srv6
                    }  // container segment-routing
                  }  // list global-af
                }  // container global-afs

                container global-graceful-maintenance-activate {
                  description
                    "Graceful maintenance activate
                   configurations";
                  container interfaces {
                    description
                      "BGP graceful maintenance interface table";
                    list interface {
                      key "interface-name";
                      description
                        "Enable graceful maintenance for e-bgp
                       directly connected neighbors going over
                       this interface";
                      leaf interface-name {
                        type xr:Interface-name;
                        description
                          "Name of Interface";
                      }
                    }  // list interface
                  }  // container interfaces

                  container locations {
                    description
                      "BGP graceful maintenance location table";
                    list location {
                      key "location";
                      description
                        "Enable graceful maintenance for e-bgp
                       directly connected neighbors going over
                       this line-card (location)";
                      leaf location {
                        type xr:Node-id;
                        description
                          "Name of Location";
                      }
                    }  // list location
                  }  // container locations

                  leaf retain-routes {
                    type boolean;
                    description
                      "BGP graceful maintenance retain routes ";
                  }

                  leaf enable {
                    type empty;
                    description
                      "Enable graceful maintenance activate
                     configuration submode";
                  }

                  leaf all-neighbors {
                    type boolean;
                    description
                      "Enable graceful maintenance for all
                     neighbors without graceful maintenance
                     config";
                  }
                }  // container global-graceful-maintenance-activate

                container rpki-static-routes {
                  description
                    "RPKI static route configuration";
                  list rpki-static-route {
                    key "address minimum maximum as";
                    description
                      "RPKI static route";
                    leaf address {
                      type inet:ip-address-no-zone;
                      description "Address";
                    }

                    leaf minimum {
                      type uint32 {
                        range "0..128";
                      }
                      description
                        "Minimum Prefix Length";
                    }

                    leaf maximum {
                      type uint32 {
                        range "1..128";
                      }
                      description
                        "Maximum Prefix Length";
                    }

                    leaf as {
                      type uint32 {
                        range
                          "1..4294967295";
                      }
                      description
                        "AS Number";
                    }
                  }  // list rpki-static-route
                }  // container rpki-static-routes

                container adjacency-table {
                  description
                    "Table of Local Adjacencies";
                  container adjacency-first-hops {
                    description
                      "Table of Firsthop addresses that form the
                     adjacencies";
                    list adjacency-first-hop {
                      key "first-hop-address";
                      description
                        "Configuration for a single adjacency";
                      container associated-peer-sets {
                        description
                          "Table of Peer sets this adjacency can be
                         part of";
                        list associated-peer-set {
                          key "peer-set";
                          description
                            "Associate this peer-set with the
                           adjacency";
                          leaf peer-set {
                            type uint32 {
                              range "1..255";
                            }
                            description
                              "Identifier value";
                          }
                        }  // list associated-peer-set
                      }  // container associated-peer-sets

                      leaf adjacency-sid {
                        type uint32 {
                          range "0..1033575";
                        }
                        description
                          "Configure Segment Index value for this
                         adjacency";
                      }

                      leaf adjacency-first-hop-enable {
                        type empty;
                        description
                          "Enable creation of this firsthop
                         adjacency";
                      }

                      leaf first-hop-address {
                        type inet:ip-address-no-zone;
                        description
                          "IP Address of Firsthop";
                      }
                    }  // list adjacency-first-hop
                  }  // container adjacency-first-hops
                }  // container adjacency-table

                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 global-scan-time {
                  type uint32 {
                    range "5..3600";
                  }
                  units "second";
                  default "60";
                  description
                    "Configure background scanner interval for
                   generic scanner";
                }

                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 "0..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 graceful-restart-neighbor-retain-disable {
                  type empty;
                  description
                    "Do not retain neighbor routes when neighbor
                   session resets if neighbor also has
                   graceful restart disabled";
                }

                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";
                }

                leaf router-id {
                  type inet:ipv4-address-no-zone;
                  default "0.0.0.0";
                  description
                    "Configure Router-id";
                }

                leaf slow-peer-detection-disable {
                  type empty;
                  description
                    "Disable slow peer detection.";
                }

                leaf disable-enforce-first-as {
                  type empty;
                  description
                    "Disable enforce the first AS for EBGP routes";
                }

                leaf best-path-cost-community {
                  type empty;
                  description
                    "Change default route selection criteria to
ignore cost community comparison";
                }

                leaf best-path-aigp-ignore {
                  type empty;
                  description
                    "Change default route selection criteria to
ignore AIGP unless both paths whichare compared
have AIGP attribute";
                }

                leaf best-path-igp-metric-sr-policy {
                  type empty;
                  description
                    "Enable BGP next-hop metric inheritance from SR
policy";
                }

                leaf next-hop-val-srte {
                  type empty;
                  description
                    "Enable BGP next-hop SR Policy reachability
validation for Extcom color paths";
                }

                leaf best-path-as-path-length {
                  type empty;
                  description
                    "Change default route selection criteria to
ignore AS path length";
                }

                leaf next-hop-val-disable {
                  type empty;
                  description
                    "Disable BGP next-hop RIB reachability validation
for Extcomm color paths";
                }

                leaf igp-redist-internal {
                  type empty;
                  description
                    "Allow redistribution of iBGP into IGPs
(dangerous)";
                }

                leaf multi-path-as-path-ignore-onwards {
                  type empty;
                  description
                    "Change default multi-route selection criteria to
ignore everything onwards as-path check";
                }

                leaf disable-fast-external-fallover {
                  type empty;
                  description
                    "Disable immediate reset session if a link to a
directly connected external peer goes down";
                }

                leaf unsafe-ebgp-policy {
                  type empty;
                  description
                    "If eBGP neighbor is configured without a
route-policy,the routes from that neighbor are
not accepted by default.This knob overrides the
default behavior. When configured,routes from
the eBGP neighbors with no policy are accepted.";
                }

                leaf default-metric {
                  type uint32 {
                    range "1..4294967295";
                  }
                  description
                    "Default redistributed metric";
                }

                leaf default-info-originate {
                  type empty;
                  description
                    "Control distribution of default information";
                }

                leaf rpki-origin-as-validity-signal-ibgp {
                  type empty;
                  description
                    "RPKI origin-AS validity signal ibgp";
                }

                leaf rpki-bestpath-use-origin-as-validity {
                  type empty;
                  description
                    "RPKI bestpath use origin-AS validity";
                }

                leaf best-path-confederation-paths {
                  type empty;
                  description
                    "Change default route selection criteria and
allow the comparing of MED among confederation
paths";
                }

                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";
                }

                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";
                    }
                  }  // list mpls-activated-interface
                }  // container mpls-activated-interfaces

                leaf disable-auto-soft-reset {
                  type empty;
                  description
                    "Disable automatic soft peer reset on policy
reconfiguration";
                }

                leaf disable-msg-log {
                  type empty;
                  description
                    "Disable inbound and outbound messagelogging for
all neighbors under the vrf";
                }

                leaf multi-path-use-cluster-list-length {
                  type empty;
                  description
                    "Change default multipath selection criteria to
consider Cluster-list length";
                }

                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";
                  }
                }  // container global-timers

                leaf best-path-igp-metric-ignore {
                  type empty;
                  description
                    "Change default route selection criteria to
ignore IGP Metric ";
                }

                leaf next-hop-res-allow-default {
                  type empty;
                  description
                    "Enable path resolution for nexthops using
default route";
                }

                leaf best-path-sr-policy-only-path {
                  type empty;
                  description
                    "Consider only paths over SR Policy for bestpath
selection";
                }

                leaf next-hop-mpls-fwd-ibgp {
                  type empty;
                  description
                    "Enable mpls forwarding path for ibgp learnt
nexthops";
                }

                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";
                  }
                }  // container bfd

                leaf disable-neighbor-logging {
                  type empty;
                  description
                    "Disable neighbor change logging";
                }

                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";
                  }
                }  // container send-socket-buffer-sizes

                leaf best-path-med-always {
                  type empty;
                  description
                    "Change default route selection criteria and
allow comparing of MED from different neighbors";
                }

                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";
                  }
                }  // container receive-socket-buffer-sizes

                leaf best-path-router-id {
                  type empty;
                  description
                    "Change default route selection criteria and
compare router-id for identical EBGP paths";
                }

                leaf best-path-med-missing {
                  type empty;
                  description
                    "Treat missing MED as the least preferred one";
                }

                leaf local-preference {
                  type uint32 {
                    range "0..4294967295";
                  }
                  default "100";
                  description
                    "Configure default local preference";
                }
              }  // container global
            }  // container default-vrf

            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";
            }
          }  // list four-byte-as
        }  // list instance-as
      }  // list instance
    }  // container bgp

    container bmp-server-all {
      status deprecated;
      description
        "This model is deprecated and is replaced by
       Cisco-IOS-XR-um-router-bgp-cfg.yang which will
       provide the compatible functionalities.  BGP BMP
       Server Common Configuration";
      container route-monitoring {
        description
          "Enable Route Monitoring capability for the BMP
         servers.
         BGP update messages messages will be
         regenrated with a table walk
        ";
        leaf policy {
          type Bmp-policy-select;
          description
            "Specify if the routes packed in update messages
           should be
           before or after the application of
           route-policy";
        }

        leaf direction {
          type Bmp-route-direction;
          description
            "Specify if the routes should be picked up at
           inbound
           or outbound direction";
        }
      }  // container route-monitoring

      leaf maximum-buffer-size {
        type uint32 {
          range "1..4294967295";
        }
        units "megabyte";
        description
          "Range in MegaBytes for the maximum buffer size
         of BMP message queue.
         The maximum buf-size is
         20% and default buf-size is 15% of the
         platform
         virtual memory max-limit (aka rlimit).
         Please run show bgp process
         performance-statistics
         to see the individual
         values. Unit is in Megabytes";
      }
    }  // container bmp-server-all

    container bmp-servers {
      status deprecated;
      description
        "This model is deprecated and is replaced by
       Cisco-IOS-XR-um-router-bgp-cfg.yang which will
       provide the compatible functionalities.  BGP BMP
       Server Configuration";
      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 "1..3600";
            }
            units "second";
            must "not(../skip)";
            description
              "Delay in seconds before sending Refresh
             request to Peers";
          }

          leaf spread {
            type uint32 {
              range "1..3600";
            }
            must "../delay and not(../skip)";
            description
              "Spread over which to send initial Refresh
             request to Peers";
          }

          leaf skip {
            type empty;
            must
              "not(../delay or ../spread)";
            description
              "Skip Route Refresh request to Peers";
          }
        }  // container initial-refresh-delay

        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 host-port

        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";
          }
        }  // container tos

        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.
           The maximum buf-size is
           20% and default buf-size is 15% of the
           platform
           virtual memory max-limit (aka rlimit)
           . Please run show bgp process
           performance-statistics
           to 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 empty;
          description
            "Shutdown connection to BMP server";
        }

        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";
        }
      }  // list bmp-server
    }  // container bmp-servers
  }  // module Cisco-IOS-XR-ipv4-bgp-cfg