module Cisco-IOS-XE-bgp-oper {

    yang-version 1;

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

    prefix bgp-ios-xe-oper;

    import Cisco-IOS-XE-bgp-common-oper {
      prefix bgp-common-ios-xe-oper;
    }
    import Cisco-IOS-XE-bgp-route-oper {
      prefix bgp-route-ios-xe-oper;
    }
    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix cisco-semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for bgp operational data.
     Copyright (c) 2016-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-11-01" {
      description
        "Added Peer Policy template";
      reference
        "3.0.0";

    }

    revision "2019-11-01" {
      description
        "Added neighbor EVPN encapsulation preference.";
      reference
        "2.5.0";

    }

    revision "2019-05-01" {
      description
        "- Added AO leaf descriptions.
       - Added semantic version";
      reference
        "2.4.0";

    }

    revision "2018-10-29" {
      description
        "Cleaned up spelling errors in descriptions.";
      reference
        "2.3.0";

    }

    revision "2017-09-25" {
      description
        "Properly indicated leaf-list ordering";
      reference
        "2.2.0";

    }

    revision "2017-05-12" {
      description
        "Added the BGP RD description";
      reference
        "2.1.0";

    }

    revision "2017-04-01" {
      description
        "Top level container name change. Enumeration name changes.";
      reference
        "2.0.0";

    }

    revision "2017-02-07" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "3.0.0";
    cisco-semver:module-version "2.5.0";
    cisco-semver:module-version "2.4.0";
    cisco-semver:module-version "2.3.0";
    cisco-semver:module-version "2.2.0";
    cisco-semver:module-version "2.1.0";
    cisco-semver:module-version "2.0.0";
    cisco-semver:module-version "1.0.0";

    typedef bgp-link {
      type enumeration {
        enum "internal" {
          value 0;
          description "iBGP neighbors";
        }
        enum "external" {
          value 1;
          description "eBGP neighbors";
        }
      }
      description
        "Operational state relevant to bgp global neighbor";
    }

    typedef bgp-fsm-state {
      type enumeration {
        enum "fsm-idle" {
          value 0;
          description
            "neighbor is in Idle state";
        }
        enum "fsm-connect" {
          value 1;
          description
            "neighbor is in Connect state";
        }
        enum "fsm-active" {
          value 2;
          description
            "neighbor is in Active state";
        }
        enum "fsm-opensent" {
          value 3;
          description
            "neighbor is in OpenSent state";
        }
        enum "fsm-openconfirm" {
          value 4;
          description
            "neighbor is in OpenConfirm state";
        }
        enum "fsm-established" {
          value 5;
          description
            "neighbor is in Established state";
        }
        enum "fsm-nonnegotiated" {
          value 6;
          description
            "neighbor is Non Negotiated";
        }
      }
      description "BGP FSM State";
    }

    typedef bgp-mode {
      type enumeration {
        enum "mode-active" {
          value 0;
          description "active connection";
        }
        enum "mode-passive" {
          value 1;
          description "passive connection";
        }
      }
      description "BGP mode";
    }

    typedef bgp-encaps-pref {
      type enumeration {
        enum "encaps-pref-unset" {
          value 0;
          description
            "Encapsulation preference is not set";
        }
        enum "encaps-pref-any" {
          value 1;
          description
            "No encapsulation is preferred";
        }
        enum "encaps-pref-vxlan-if-vtep-up" {
          value 2;
          description
            "Use VxLAN if VTEP is UP else use MPLS";
        }
        enum "encaps-pref-vxlan" {
          value 3;
          description
            "Prefer VxLAN encapsulation";
        }
        enum "encaps-pref-mpls" {
          value 4;
          description
            "Prefer MPLS encapsulation";
        }
      }
      description
        "BGP encapsulation preferences";
    }

    grouping configured-peer-policy {
      description "Configured Peer Policy";
      leaf distribute-list-in {
        type string;
        description
          "Incoming update network filter list name";
      }

      leaf prefix-list-in {
        type string;
        description
          "Incoming update prefix filter list name";
      }

      leaf filter-list-in {
        type uint32;
        description
          "Incoming update AS path filter list";
      }

      leaf route-map-in {
        type string;
        description
          "Route map for incoming advertisements";
      }

      leaf prefix-list-out {
        type string;
        description
          "Outgoing update prefix filter list name";
      }

      leaf distribute-list-out {
        type string;
        description
          "Outgoing update network filter list name";
      }

      leaf filter-list-out {
        type uint32;
        description
          "Outgoing update AS path filter list";
      }

      leaf route-map-out {
        type string;
        description
          "Route map for outgoing advertisements";
      }

      leaf unsuppress-map {
        type string;
        description
          "Route map for selective unsuppress";
      }

      leaf default-originate {
        type boolean;
        description
          "Originate default route to this neighbor";
      }

      leaf default-map {
        type string;
        description
          "Set a command to its defaults";
      }

      leaf weight {
        type uint32;
        description
          "Set default weight for routes from this neighbor";
      }

      leaf soft-reconfig-in {
        type boolean;
        description
          "Per neighbor soft reconfiguration";
      }

      leaf maximum-prefix {
        type uint32;
        description
          "Maximum number of prefixes accepted from this peer";
      }

      leaf max-prefix-threshold {
        type uint32;
        description "Max prefix threshold";
      }

      leaf max-prefix-warning {
        type boolean;
        description "Max prefix warning";
      }

      leaf max-pfx-restart-interval {
        type uint32;
        description
          "Max prefix restart interval";
      }

      leaf as-override {
        type boolean;
        description
          "Override matching AS number while sending update";
      }

      leaf as-override-split-horizon {
        type boolean;
        description
          "Split horizon processing before sending updates";
      }

      leaf allow-as {
        type uint32;
        description
          "Accept as-path with my AS present in it";
      }

      leaf allow-policy {
        type boolean;
        description
          "Enable the policy support for this IBGP Neighbor";
      }

      leaf rr-client {
        type boolean;
        description
          "Configure a neighbor as Route Reflector client";
      }

      leaf aigp {
        type boolean;
        description
          "aigp attribute sent to this neighbor";
      }

      leaf aigp-med {
        type boolean;
        description
          "aigp as med attribute sent to this neighbor";
      }

      leaf aigp-cost {
        type boolean;
        description
          "aigp as cost-community attribute sent to this neighbor";
      }

      leaf internal-vpn-client {
        type boolean;
        description "Internal vpn client";
      }

      leaf advertisement-interval {
        type uint32;
        description "Advertisement interval";
      }

      leaf nexthop-unchanged {
        type boolean;
        description
          "Propagate the iBGP path's next hop unchanged for this neighbor";
      }

      leaf nexthop-unchanged-all {
        type boolean;
        description
          "Propagate next hop unchanged for all paths to this neighbor";
      }

      leaf nexthop-self {
        type boolean;
        description
          "Disable the next hop calculation for this neighbor";
      }

      leaf nexthop-self-all {
        type boolean;
        description
          "Disable the next hop EBGP calculation for this neighbor";
      }

      leaf add-path-send {
        type boolean;
        description
          "Advertise additional paths ";
      }

      leaf add-path-rx {
        type boolean;
        description
          "Receive additional paths";
      }

      leaf adv-add-path-all {
        type boolean;
        description "Advertise all paths";
      }

      leaf adv-add-path-grp-best {
        type boolean;
        description "Advertise best paths";
      }

      leaf adv-add-path-bestn {
        type uint32;
        description "Advertise best n paths";
      }

      leaf adv-diverse-path {
        type string;
        description "Advertise diverse path";
      }

      leaf adv-best-ext {
        type boolean;
        description
          "Advertise best external path";
      }

      leaf slow-peer-static {
        type boolean;
        description "Slow peer static";
      }

      leaf sp-detect-thold {
        type uint32;
        description
          "Slow peer detection threshold";
      }

      leaf sp-dynamic {
        type boolean;
        description "Slow update group";
      }

      leaf sp-protection-permanent {
        type boolean;
        description
          "Slow peer protection permanent";
      }

      leaf send-community {
        type string;
        description
          "Send community attribute to this neighbor";
      }

      leaf flow-spec-validation-off {
        type boolean;
        description
          "Disable flow spec validation";
      }

      leaf valid-redirect-off {
        type boolean;
        description
          "Disable validations on Redirect-IP ext comm";
      }

      leaf remove-private-as {
        type boolean;
        description
          "Remove private AS number for outbound updates";
      }

      leaf remove-private-as-all {
        type boolean;
        description "Remove private AS all";
      }

      leaf rm-private-as-replace-as {
        type boolean;
        description "Replace private AS";
      }

      leaf extcommunity {
        type string;
        description
          "extcommunity description";
      }

      leaf rpki-state-enabled {
        type boolean;
        description
          "RPKI-State extended community enabled";
      }

      leaf dmzlink-bw {
        type boolean;
        description
          "Propagate the DMZ link bandwidth";
      }

      leaf send-label {
        type boolean;
        description
          "Send Label to this peer";
      }

      leaf send-label-explicit-null {
        type boolean;
        description
          "Send Label explicit null";
      }

      leaf encap {
        type string;
        description
          "Preferred encapsulation name for the neighbor";
      }

      leaf cap-orf-prefix-list {
        type string;
        description
          "Advertise capability to the peer";
      }

      leaf translate-topology {
        type uint32;
        description "Translate topology";
      }

      leaf accept-route-legacy-rt {
        type boolean;
        description "Accept route legacy rt";
      }

      leaf inter-as-hybrid {
        type boolean;
        description "Enable Inter AS hybrid";
      }

      leaf suppress-ldp {
        type boolean;
        description "Suppress ldp";
      }

      leaf llgr-stale-time-send {
        type uint32;
        description
          "Send long live graceful restart stale time";
      }

      leaf llgr-stale-time-accept {
        type uint32;
        description
          "Receive long live graceful restart stale time";
      }
    }  // grouping configured-peer-policy

    grouping inherited-peer-policy {
      description "Inherited Peer Policy";
      leaf-list name {
        type string;
        ordered-by user;
        description
          "Name of the inherited peer policy";
      }

      container configured-policies {
        description
          "Configured policies in a peer policy";
        uses bgp-ios-xe-oper:configured-peer-policy;
      }  // container configured-policies
    }  // grouping inherited-peer-policy

    grouping peer-policy-summary {
      description "Peer Policy summary";
      leaf name {
        type string;
        description
          "Name of the Peer Policy";
      }

      leaf total-inherited {
        type uint32;
        description
          "Total number of inherited policies";
      }

      leaf index {
        type uint32;
        description
          "Index of the peer policy";
      }

      container configured-policies {
        description
          "Configured policies in a peer policy";
        uses bgp-ios-xe-oper:configured-peer-policy;
      }  // container configured-policies

      container inherited-policies {
        description
          "Inherited policies in a peer policy";
        uses bgp-ios-xe-oper:inherited-peer-policy;
      }  // container inherited-policies
    }  // grouping peer-policy-summary

    grouping bgp-message-counters {
      description "BGP message counters";
      leaf opens {
        type uint32;
        description "OPEN message count";
      }

      leaf updates {
        type uint32;
        description "UPDATE message count";
      }

      leaf notifications {
        type uint32;
        description
          "NOTIFICATION message count";
      }

      leaf keepalives {
        type uint32;
        description
          "KEEPALIVE message count";
      }

      leaf route-refreshes {
        type uint32;
        description
          "Route refresh message count";
      }
    }  // grouping bgp-message-counters

    grouping bgp-prefix-counters {
      description
        "Grouping for various prefix counters";
      leaf current-prefixes {
        type uint64;
        description
          "The current number of accepted prefixes";
      }

      leaf total-prefixes {
        type uint64;
        description
          "The total number of accepted prefixes";
      }

      leaf implicit-withdraw {
        type uint64;
        description
          "The number of times a prefix has been
         withdrawn and readvertised";
      }

      leaf explicit-withdraw {
        type uint64;
        description
          "The number of times a prefix has been
         withdrawn because it is no longer feasible";
      }

      leaf bestpaths {
        type uint64;
        description
          "The number of received prefixes installed as best paths";
      }

      leaf multipaths {
        type uint64;
        description
          "The number of received prefixes installed as multipaths";
      }
    }  // grouping bgp-prefix-counters

    grouping negotiated-keepalive-timers {
      description
        "Negotiated keepalive timers details";
      leaf hold-time {
        type uint16;
        description "Hold time";
      }

      leaf keepalive-interval {
        type uint16;
        description "Keepalive interval";
      }
    }  // grouping negotiated-keepalive-timers

    grouping neighbor-summary {
      description
        "Information regarding the current state of a neighbor";
      leaf id {
        type string;
        description "Neighbor address";
      }

      leaf bgp-version {
        type uint32;
        description "BGP protocol version";
      }

      leaf messages-received {
        type uint64;
        description
          "Number of messages received from this neighbor";
      }

      leaf messages-sent {
        type uint64;
        description
          "Number of messages sent to this neighbor";
      }

      leaf table-version {
        type uint64;
        description "BGP table version";
      }

      leaf input-queue {
        type uint64;
        description
          "Number of messages in input queue";
      }

      leaf output-queue {
        type uint64;
        description
          "Number of messages in output queue";
      }

      leaf up-time {
        type string;
        description
          "Neighbor session uptime";
      }

      leaf state {
        type bgp-fsm-state;
        description "BGP session state";
      }

      leaf prefixes-received {
        type uint64;
        description
          "Number of prefixes received from the neighbor";
      }

      leaf dynamically-configured {
        type boolean;
        description
          "Indication of whether the neighbor was
         dynamically configured";
      }

      leaf as {
        type uint32;
        description "BGP neighbor AS number";
      }
    }  // grouping neighbor-summary

    grouping bgp-connection {
      description
        "Data for current BGP connection state";
      leaf state {
        type bgp-common-ios-xe-oper:tcp-fsm-state;
        description "TCP FSM state";
      }

      leaf mode {
        type bgp-mode;
        description
          "BGP transport connection mode";
      }

      leaf total-established {
        type uint32;
        description
          "The number of times a TCP and BGP
         connection has been successfully established";
      }

      leaf total-dropped {
        type uint32;
        description
          "The number of times that a valid
         session has failed or been taken down";
      }

      leaf last-reset {
        type string;
        description
          "Time since peering session was last reset";
      }

      leaf reset-reason {
        type string;
        description
          "The reason for the last reset";
      }
    }  // grouping bgp-connection

    grouping bgp-transport {
      description
        "BGP transport information";
      leaf path-mtu-discovery {
        type boolean;
        description
          "Indication whether path MTU discovery is enabled";
      }

      leaf local-port {
        type uint32;
        description
          "Local TCP port used for TCP session";
      }

      leaf local-host {
        type inet:ip-address;
        description
          "Local address used for the TCP session";
      }

      leaf foreign-port {
        type uint32;
        description
          "Remote port used by the peer for the TCP session";
      }

      leaf foreign-host {
        type inet:ip-address;
        description
          "Remote address of the BGP session";
      }

      leaf mss {
        type uint32;
        description
          "Maximum Data segment size";
      }

      leaf ao-keychain-name {
        type string;
        description
          "Name of the Key Chain for AO";
      }

      leaf ao-key-id {
        type int32;
        description "ID of the key for AO";
      }

      leaf ao-incl-tcp-opts {
        type boolean;
        description "AO Include TCP Options";
      }

      leaf ao-accept-mismatch-conn {
        type boolean;
        description
          "AO Accept Mismatched Connections";
      }
    }  // grouping bgp-transport

    grouping bgp-af-prefix-activity {
      description
        "Address family prefix statistics";
      container sent {
        description
          "Number of prefixes sent";
        uses bgp-ios-xe-oper:bgp-prefix-counters;
      }  // container sent

      container received {
        description
          "Number of prefixes received";
        uses bgp-ios-xe-oper:bgp-prefix-counters;
      }  // container received
    }  // grouping bgp-af-prefix-activity

    grouping bgp-neighbor-counters {
      description
        "BGP neighbor session counters";
      container sent {
        description
          "Number of messages sent";
        uses bgp-ios-xe-oper:bgp-message-counters;
      }  // container sent

      container received {
        description
          "Number of messages received";
        uses bgp-ios-xe-oper:bgp-message-counters;
      }  // container received

      leaf inq-depth {
        type uint32;
        description "Input Q depth";
      }

      leaf outq-depth {
        type uint32;
        description "Output Q depth";
      }
    }  // grouping bgp-neighbor-counters

    grouping neighbor-key {
      description
        "Grouping for neighbor key";
      leaf afi-safi {
        type bgp-common-ios-xe-oper:afi-safi;
        description "Afi-safi key";
      }

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

      leaf neighbor-id {
        type string;
        description "Neighbor identifier";
      }
    }  // grouping neighbor-key

    grouping neighbor {
      description
        "BGP neighbor state information";
      leaf description {
        type string;
        description
          "Neighbor description string";
      }

      leaf bgp-version {
        type uint16;
        description
          "BGP version being used to communicate
         with the remote router";
      }

      leaf link {
        type bgp-link;
        description "Neighbor link type";
      }

      leaf up-time {
        type string;
        description
          "Amount of time the bgp session has been
         up since being established";
      }

      leaf last-write {
        type string;
        description
          "Time since BGP last sent a message to the neighbor";
      }

      leaf last-read {
        type string;
        description
          "Time since BGP last received a message from the neighbor";
      }

      leaf installed-prefixes {
        type uint32;
        description
          "The number of installed prefixes";
      }

      leaf session-state {
        type bgp-fsm-state;
        description
          "BGP neighbor session state";
      }

      container negotiated-keepalive-timers {
        description
          "Negotiated keepalive timers status of BGP neighbor";
        uses bgp-ios-xe-oper:negotiated-keepalive-timers;
      }  // container negotiated-keepalive-timers

      leaf-list negotiated-cap {
        type string;
        ordered-by user;
        description
          "Negotiated capabilities for neighbor session";
      }

      container bgp-neighbor-counters {
        description
          "BGP neighbor session counters";
        uses bgp-ios-xe-oper:bgp-neighbor-counters;
      }  // container bgp-neighbor-counters

      container connection {
        description
          "BGP neighbor connection";
        uses bgp-ios-xe-oper:bgp-connection;
      }  // container connection

      container transport {
        description "BGP neighbor transport";
        uses bgp-ios-xe-oper:bgp-transport;
      }  // container transport

      container prefix-activity {
        description "BGP neighbor activity";
        uses bgp-ios-xe-oper:bgp-af-prefix-activity;
      }  // container prefix-activity

      leaf as {
        type uint32;
        description "BGP neighbor AS number";
      }

      leaf encaps-pref {
        type bgp-encaps-pref;
        description
          "Preferred tunnel encapsulation type";
      }

      container peer-policy {
        description "Peer policy template";
        uses bgp-ios-xe-oper:peer-policy-summary;
      }  // container peer-policy
    }  // grouping neighbor

    grouping entry-stats {
      description "BGP entry statistics";
      leaf total-entries {
        type uint64;
        description
          "The total number of prefix entries";
      }

      leaf memory-usage {
        type uint64;
        description
          "Total memory usage in byte";
      }
    }  // grouping entry-stats

    grouping activities {
      description "BGP activity information";
      leaf prefixes {
        type uint64;
        description
          "Total number of prefixes";
      }

      leaf paths {
        type uint64;
        description "Total number of paths";
      }

      leaf scan-interval {
        type string;
        description
          "Scan interval in seconds";
      }
    }  // grouping activities

    grouping address-family-key {
      description "Address family key";
      leaf afi-safi {
        type bgp-common-ios-xe-oper:afi-safi;
        description "Afi-safi value";
      }

      leaf vrf-name {
        type string;
        description "VRF name";
      }
    }  // grouping address-family-key

    grouping address-family-summary {
      description
        "Summary of address family";
      leaf router-id {
        type inet:ip-address;
        description "Router ID";
      }

      leaf bgp-table-version {
        type uint64;
        description
          "BGP table version number";
      }

      leaf routing-table-version {
        type uint64;
        description
          "Routing table version number";
      }

      container prefixes {
        description
          "Prefix entry statistics";
        uses bgp-ios-xe-oper:entry-stats;
      }  // container prefixes

      container path {
        description "Path entry statistics";
        uses bgp-ios-xe-oper:entry-stats;
      }  // container path

      container as-path {
        description
          "AS path entry statistics";
        uses bgp-ios-xe-oper:entry-stats;
      }  // container as-path

      container route-map {
        description
          "Route map entry statistics";
        uses bgp-ios-xe-oper:entry-stats;
      }  // container route-map

      container filter-list {
        description
          "Filter list entry statistics";
        uses bgp-ios-xe-oper:entry-stats;
      }  // container filter-list

      container activities {
        description
          "BGP activity information";
        uses bgp-ios-xe-oper:activities;
      }  // container activities

      leaf total-memory {
        type uint64;
        description "Total memory in use";
      }

      container bgp-neighbor-summaries {
        description "Neighbor summary";
        list bgp-neighbor-summary {
          key "id";
          description
            "List of neighbor summaries";
          uses bgp-ios-xe-oper:neighbor-summary;
        }  // list bgp-neighbor-summary
      }  // container bgp-neighbor-summaries

      leaf local-as {
        type uint32;
        description "Local AS number";
      }
    }  // grouping address-family-summary

    grouping bgp-state {
      description "BGP state information";
      container neighbors {
        description
          "BGP neighbor information";
        list neighbor {
          key "afi-safi vrf-name neighbor-id";
          description
            "List of BGP neighbors";
          uses bgp-ios-xe-oper:neighbor-key;

          uses bgp-ios-xe-oper:neighbor;
        }  // list neighbor
      }  // container neighbors

      container address-families {
        description "BGP address family";
        list address-family {
          key "afi-safi vrf-name";
          description
            "List of BGP address families";
          uses bgp-ios-xe-oper:address-family-key;

          uses bgp-ios-xe-oper:address-family-summary;
        }  // list address-family
      }  // container address-families

      container bgp-route-vrfs {
        description "BGP VRFs";
        list bgp-route-vrf {
          key "vrf";
          description "List of BGP VRFs";
          uses bgp-route-ios-xe-oper:vrf-record;
        }  // list bgp-route-vrf
      }  // container bgp-route-vrfs

      container bgp-route-rds {
        description "BGP RDs";
        list bgp-route-rd {
          key "rd-value";
          description "List of BGP RDs";
          uses bgp-route-ios-xe-oper:bgp-rd-record;
        }  // list bgp-route-rd
      }  // container bgp-route-rds
    }  // grouping bgp-state

    container bgp-state-data {
      config false;
      description
        "BGP operational state data";
      uses bgp-ios-xe-oper:bgp-state;
    }  // container bgp-state-data
  }  // module Cisco-IOS-XE-bgp-oper