submodule openconfig-rib-bgp-attributes {

    yang-version 1;

    belongs-to openconfig-rib-bgp {
        prefix oc-rib-bgp;
    }

    import openconfig-bgp-types {
      prefix oc-bgpt;
    }
    import openconfig-extensions {
      prefix oc-ext;
    }
    import openconfig-rib-bgp-types {
      prefix oc-bgprt;
    }
    import openconfig-segment-routing {
      prefix oc-sr;
    }
    import openconfig-inet-types {
      prefix oc-inet;
    }

    organization "OpenConfig working group";

    contact
      "OpenConfig working group
    www.openconfig.net";

    description
      "This submodule contains common data definitions for BGP
    attributes for use in BGP RIB tables.";

    revision "2019-04-25" {
      description
        "Update last-modified timestamp to be expressed as nanoseconds
      since the Unix epoch.";
      reference
        "0.6.0";

    }

    revision "2019-04-16" {
      description
        "Rename the top-level BGP RIB container's name
      to RIB.";
      reference
        "0.5.0";

    }

    revision "2019-02-27" {
      description
        "Remove top-level BGP RIB container, and update list
      names to be compatible with path compression.";
      reference
        "0.4.0";

    }

    revision "2018-11-21" {
      description
        "Add OpenConfig module metadata extensions.";
      reference
        "0.3.1";

    }

    revision "2016-10-17" {
      description
        "OpenConfig BGP RIB refactor";
      reference
        "0.3.0";

    }

    oc-ext:openconfig-version "0.6.0";

    grouping bgp-as-path-attr-state {
      description
        "Data for representing BGP AS-PATH attribute";
      leaf type {
        type oc-bgpt:as-path-segment-type;
        description
          "The type of AS-PATH segment";
      }

      leaf-list member {
        type oc-inet:as-number;
        description
          "List of the AS numbers in the AS-PATH segment";
      }
    }  // grouping bgp-as-path-attr-state

    grouping bgp-as-path-attr-top {
      description
        "Top-level grouping for AS-PATH attribute data";
      container as-path {
        description
          "Enclosing container for the list of AS path segments.

        In the Adj-RIB-In or Adj-RIB-Out, this list should show
        the received or sent AS_PATH, respectively.  For
        example, if the local router is not 4-byte capable, this
        value should consist of 2-octet ASNs or the AS_TRANS
        (AS 23456) values received or sent in route updates.

        In the Loc-RIB, this list should reflect the effective
        AS path for the route, e.g., a 4-octet value if the
        local router is 4-octet capable.";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)
           RFC 6793 - BGP Support for Four-octet AS Number Space
           RFC 5065 - Autonomous System Confederations for BGP";

        list as-segment {
          description
            "Unkeyed list of AS PATH segments";
          container state {
            config false;
            description
              "Opstate data for AS-PATH segments";
            uses bgp-as-path-attr-state;
          }  // container state
        }  // list as-segment
      }  // container as-path
    }  // grouping bgp-as-path-attr-top

    grouping bgp-as4-path-attr-top {
      description
        "Top-level grouping for AS4-PATH attribute data";
      container as4-path {
        description
          "This is the path encoded with 4-octet
        AS numbers in the optional transitive AS4_PATH attribute.
        This value is populated with the received or sent attribute
        in Adj-RIB-In or Adj-RIB-Out, respectively.  It should not
        be populated in Loc-RIB since the Loc-RIB is expected to
        store the effective AS-Path in the as-path leaf regardless
        of being 4-octet or 2-octet.";
        reference
          "RFC 6793 - BGP Support for Four-octet AS Number Space";

        list as4-segment {
          description
            "Unkeyed list of AS PATH segments";
          container state {
            config false;
            description
              "Opstate data for AS-PATH segments";
            uses bgp-as-path-attr-state;
          }  // container state
        }  // list as4-segment
      }  // container as4-path
    }  // grouping bgp-as4-path-attr-top

    grouping bgp-community-attr-state {
      description
        "Common definition of BGP community attributes";
      leaf-list community {
        type union {
          type oc-bgpt:bgp-well-known-community-type;
          type oc-bgpt:bgp-std-community-type;
        }
        description
          "List of standard or well-known BGP community
        attributes.";
      }
    }  // grouping bgp-community-attr-state

    grouping bgp-extended-community-attr-state {
      description
        "Common definition of BGP extended community attribute";
      leaf-list ext-community {
        type oc-bgpt:bgp-ext-community-recv-type;
        description
          "List of BGP extended community attributes.  The received
        extended community may be an explicitly modeled
        type or unknown, represented by an 8-octet value
        formatted according to RFC 4360.";
        reference
          "RFC 4360 - BGP Extended Communities Attribute";

      }
    }  // grouping bgp-extended-community-attr-state

    grouping bgp-aggregator-attr-state {
      description
        "Operational state data for the BGP aggregator
      attribute";
      leaf as {
        type oc-inet:as-number;
        description
          "AS number of the autnonomous system that performed the
          aggregation.";
      }

      leaf as4 {
        type oc-inet:as-number;
        description
          "AS number of the autnonomous system that performed the
        aggregation (4-octet representation).  This value is
        populated if an upstream router is not 4-octet capable.
        Its semantics are similar to the AS4_PATH optional
        transitive attribute";
        reference
          "RFC 6793 - BGP Support for Four-octet AS Number Space";

      }

      leaf address {
        type oc-inet:ipv4-address;
        description
          "IP address of the router that performed the
        aggregation.";
      }
    }  // grouping bgp-aggregator-attr-state

    grouping bgp-aggregator-attr-top {
      description
        "Common definition of the BGP aggregator attribute";
      container aggregator {
        description
          "BGP attribute indicating the prefix has been aggregated by
        the specified AS and router.";
        container state {
          config false;
          description
            "Operational state data for BGP aggregator attribute";
          uses bgp-aggregator-attr-state;
        }  // container state
      }  // container aggregator
    }  // grouping bgp-aggregator-attr-top

    grouping bgp-shared-common-attr-state {
      description
        "Route attributes shared across route table entries,
      common to both LOC-Rib and Adj-RIB";
      leaf origin {
        type oc-bgpt:bgp-origin-attr-type;
        description
          "BGP attribute defining the origin of the path information.";
      }

      leaf atomic-aggregate {
        type boolean;
        description
          "BGP attribute indicating that the prefix is an atomic
        aggregate, i.e., the peer selected a less specific
        route without selecting a more specific route that is
        included in it.";
      }

      leaf next-hop {
        type oc-inet:ip-address;
        description
          "BGP next hop attribute defining the IP address of the router
        that should be used as the next hop to the destination";
      }

      leaf med {
        type uint32;
        description
          "BGP multi-exit discriminator attribute used in BGP route
        selection process";
      }

      leaf local-pref {
        type uint32;
        description
          "BGP local preference attribute sent to internal peers to
        indicate the degree of preference for externally learned
        routes.  The route with the highest local preference value
        is preferred.";
      }

      leaf originator-id {
        type oc-inet:ipv4-address;
        description
          "BGP attribute that provides the id as an IPv4 address
        of the originator of the announcement.";
        reference
          "RFC 4456 - BGP Route Reflection: An Alternative to Full
          Mesh Internal BGP (IBGP)";

      }

      leaf-list cluster-list {
        type oc-inet:ipv4-address;
        description
          "Represents the reflection path that the route has passed.";
        reference
          "RFC 4456 - BGP Route Reflection: An Alternative to Full
          Mesh Internal BGP (IBGP)";

      }

      leaf aigp {
        type uint64;
        description
          "BGP path attribute representing the accumulated IGP metric
        for the path";
        reference
          "RFC 7311 - The Accumulated IGP Metric Attribute for BGP";

      }
    }  // grouping bgp-shared-common-attr-state

    grouping bgp-unknown-attr-flags-state {
      description
        "Operational state data for path attribute flags";
      leaf optional {
        type boolean;
        description
          "Defines whether the attribute is optional (if
         set to true) or well-known (if set to false).
         Set in the high-order bit of the BGP attribute
         flags octet.";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }

      leaf transitive {
        type boolean;
        description
          "Defines whether an optional attribute is transitive
        (if set to true) or non-transitive (if set to false).  For
        well-known attributes, the transitive flag MUST be set to
        true.  Set in the second high-order bit of the BGP attribute
        flags octet.";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }

      leaf partial {
        type boolean;
        description
          "Defines whether the information contained in the optional
        transitive attribute is partial (if set to true) or complete
        (if set to false).  For well-known attributes and for
        optional non-transitive attributes, the partial flag
        must be set to false.  Set in the third high-order bit of
        the BGP attribute flags octet.";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }

      leaf extended {
        type boolean;
        description
          "Defines whether the attribute length is one octet
        (if set to false) or two octets (if set to true).  Set in
        the fourth high-order bit of the BGP attribute flags
        octet.";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }
    }  // grouping bgp-unknown-attr-flags-state

    grouping bgp-unknown-attr-state {
      description
        "Operational state data for path attributes not shared
      across route entries, common to LOC-RIB and Adj-RIB";
      leaf attr-type {
        type uint8;
        description
          "1-octet value encoding the attribute type code";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }

      leaf attr-len {
        type uint16;
        description
          "One or two octet attribute length field indicating the
        length of the attribute data in octets.  If the Extended
        Length attribute flag is set, the length field is 2 octets,
        otherwise it is 1 octet";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }

      leaf attr-value {
        type binary {
          length "1..65535";
        }
        description
          "Raw attribute value, not including the attribute
        flags, type, or length.  The maximum length
        of the attribute value data is 2^16-1 per the max value
        of the attr-len field (2 octets).";
        reference
          "RFC 4271 - A Border Gateway Protocol 4 (BGP-4)";

      }
    }  // grouping bgp-unknown-attr-state

    grouping bgp-unknown-attr-top {
      description
        "Unknown path attributes that are not expected to be shared
      across route entries, common to LOC-RIB and Adj-RIB";
      container unknown-attributes {
        description
          "Unknown path attributes that were received in the UPDATE
        message which contained the prefix.";
        list unknown-attribute {
          key "attr-type";
          description
            "This list contains received attributes that are unrecognized
          or unsupported by the local router.  The list may be empty.";
          leaf attr-type {
            type leafref {
              path "../state/attr-type";
            }
            description
              "Reference to the list key";
          }

          container state {
            description
              "Operational state for unknown route attributes";
            uses bgp-unknown-attr-flags-state;

            uses bgp-unknown-attr-state;
          }  // container state
        }  // list unknown-attribute
      }  // container unknown-attributes
    }  // grouping bgp-unknown-attr-top

    grouping bgp-loc-rib-attr-state {
      description
        "Path attributes that are not expected to be shared across
      route entries, specific to LOC-RIB";
    }  // grouping bgp-loc-rib-attr-state

    grouping bgp-adj-rib-attr-state {
      description
        "Path attributes that are not expected to be shared across
      route entries, specific to Adj-RIB";
      leaf path-id {
        type uint32;
        description
          "When the BGP speaker supports advertisement of multiple
        paths for a prefix, the path identifier is used to
        uniquely identify a route based on the combination of the
        prefix and path id.  In the Adj-RIB-In, the path-id value is
        the value received in the update message.   In the Loc-RIB,
        if used, it should represent a locally generated path-id
        value for the corresponding route.  In Adj-RIB-Out, it
        should be the value sent to a neighbor when add-paths is
        used, i.e., the capability has been negotiated.";
        reference
          "draft-ietf-idr-add-paths - Advertisement of Multiple Paths
          in BGP";

      }
    }  // grouping bgp-adj-rib-attr-state

    grouping bgp-tunnel-encapsulation-attr-top {
      description
        "Top-level definition of the BGP Tunnel encapsulation
      attribute.";
      container tunnel-encapsulation {
        config false;
        description
          "The Tunnel Encapsulation attribute specifies a set of
        tunnels to a remote destination. The attribute is TLV
        based and allows description of a tunnel type, and the
        relevant information to create the tunnel to the remote
        destination.";
        reference
          "RFC5512, draft-ietf-idr-tunnel-encaps";

        container tunnels {
          description
            "Surrounding container for the set of tunnels included
          within the tunnel encapsulation attribute.";
          list tunnel {
            key "type";
            description
              "List of the tunnels that are specified within the
            attribute. Keyed on the type of tunnel that the
            TLV describes.";
            leaf type {
              type leafref {
                path "../state/type";
              }
              description
                "Reference to the tunnel type specified within the
              TLV's type field.";
            }

            container state {
              config false;
              description
                "State parameters of the tunnel attribute";
              uses bgp-tunnel-encapsulation-attr-tunnel-state;
            }  // container state

            container subtlvs {
              description
                "Surrounding container for the list of sub-TLVs within
              the tunnel encapsulation attribute.";
              list subtlv {
                key "type";
                description
                  "List of the subTLVs that are specified within the
                TLV instance inside the tunnel encapsulation attribute.";
                leaf type {
                  type leafref {
                    path "../state/type";
                  }
                  description
                    "Reference to the sub-TLV type that is included within
                  the subTLV.";
                }

                container state {
                  config false;
                  description
                    "State parameters of the subTLV of the tunnel attribute";
                  uses bgp-tunnel-encapsulation-attr-tunnel-subtlv-state;
                }  // container state

                container remote-endpoints {
                  when
                    "../state/type = 'oc-bgprt:TUNNEL_REMOTE_ENDPOINT'" {
                    description
                      "Only allow the remote endpoint to be specified when the
                    subTLV is specified to describe remote endpoints.";
                  }
                  description
                    "The remote endpoints associated with the tunnel
                  described by the attribute.";
                  list remote-endpoint {
                    key "endpoint";
                    description
                      "List of the remote endpoints described within the TLV.";
                    leaf endpoint {
                      type leafref {
                        path
                          "../state/endpoint";
                      }
                      description
                        "Reference to the IP address of the endpoint.";
                    }

                    container state {
                      config false;
                      description
                        "State parameters of the remote endpoints described
                      by the attribute.";
                      uses bgp-tunnel-encapsulation-attr-tunnel-subtlv-endpoint-state;
                    }  // container state
                  }  // list remote-endpoint
                }  // container remote-endpoints

                container segment-lists {
                  when
                    "../state/type = 'oc-bgprt:SRTE_SEGMENT_LIST'" {
                    description
                      "Only allow the segment lists to be specified when the sub-TLV
                    is of the relevant type.";
                  }
                  description
                    "Surrounding container for the list of segment lists that are
                  associated with a SR-TE Policy tunnel.";
                  list segment-list {
                    key "instance-id";
                    description
                      "List of segment lists that are specified within the
                    tunnel encapsulation attribute.";
                    leaf instance-id {
                      type leafref {
                        path
                          "../state/instance-id";
                      }
                      description
                        "Reference to the instance identifier of the Segment List
                      that is included within the tunnel encapsulation
                      attribute.";
                    }

                    container state {
                      config false;
                      description
                        "State parameters relating to the Segment List within the
                      Tunnel Encapsulation attribute.";
                      uses bgp-tunnel-encapsulation-attr-tunnel-subtlv-segment-list-state;
                    }  // container state

                    container segments {
                      description
                        "Surrounding container for the list of segments within the
                      SR-TE segment list.";
                      list segment {
                        key "index";
                        description
                          "List of segments within the SR-TE segment list.";
                        leaf index {
                          type leafref {
                            path
                              "../state/index";
                          }
                          description
                            "Reference to the index of the segment within the
                          segment list.";
                        }

                        container state {
                          config false;
                          description
                            "State parameters relating to the segment within
                          the segment list.";
                          uses bgp-tunnel-encapsulation-attr-tunnel-subtlv-segment-state;
                        }  // container state
                      }  // list segment
                    }  // container segments
                  }  // list segment-list
                }  // container segment-lists
              }  // list subtlv
            }  // container subtlvs
          }  // list tunnel
        }  // container tunnels
      }  // container tunnel-encapsulation
    }  // grouping bgp-tunnel-encapsulation-attr-top

    grouping bgp-tunnel-encapsulation-attr-tunnel-state {
      description
        "State parameters of the tunnel encapsulation attribute";
      leaf type {
        type identityref {
          base oc-bgprt:TUNNEL_ENCAPSULATION_TYPE;
        }
        description
          "Type of the tunnel described within the tunnel encapsulation
        attribute.";
      }
    }  // grouping bgp-tunnel-encapsulation-attr-tunnel-state

    grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-state {
      description
        "State parameters relating to subTLVs of the tunnel encapsulation
      attribute.";
      leaf type {
        type identityref {
          base oc-bgprt:TUNNEL_ENCAPSULATION_SUBTLV_TYPE;
        }
        description
          "Type of the sub-TLV within the tunnel encapsulation attribute";
      }

      leaf-list colors {
        when
          "../type = 'oc-bgprt:TUNNEL_COLOR'" {
          description
            "Only allow list of colours to be specified when the sub-TLV
          specifies colours associated with the tunnel encapsulation
          attribute.";
        }
        type uint32;
        description
          "The colours associated with the tunnel encapsulation attribute,
        as described by RFC5512.";
      }

      leaf preference {
        when
          "../type = 'oc-bgprt:SRTE_PREFERENCE'" {
          description
            "Only allow the preference to be specified when the sub-TLV
          specifies the preference associated with the tunnel encapsulation
          attribute.";
        }
        type uint32;
        default '100';
        description
          "The preference of the SR-TE policy described by the tunnel
        encapsulation attribute. If unspecified, the preference
        defaults to 100.";
      }

      leaf binding-sid {
        when
          "../type = 'oc-bgprt:SRTE_BINDING_SID'" {
          description
            "Only allow the binding SID to be specified when the sub-TLV
          is specified to be the of the relevant type.";
        }
        type oc-sr:sr-sid-type;
        description
          "Binding SID associated with the SR-TE policy";
      }
    }  // grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-state

    grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-endpoint-state {
      description
        "State parameters relating to the remote endpoint described by a
      tunnel encapsulation attribute.";
      leaf as {
        type oc-inet:as-number;
        description
          "The remote AS to which the IP address of the remote endpoint
        belongs.";
      }

      leaf endpoint {
        type oc-inet:ip-address;
        description
          "IP address of the remote endpoint.";
      }
    }  // grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-endpoint-state

    grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-segment-list-state {
      description
        "State parameters relating to an entry within a segment list within
      a SR-TE policy segment list.";
      leaf instance-id {
        type uint64;
        description
          "Instance of the segment list within the sub-TLV";
      }

      leaf weight {
        type uint32;
        description
          "The weight given to the path within the set of segment
        lists that are included in the tunnel attribute sub-TLV.";
      }
    }  // grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-segment-list-state

    grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-segment-state {
      description
        "State parameters relating to a segment within the segment list.";
      leaf index {
        type uint64;
        description
          "Index of the segment within the segment list. The segments are
        ordered in ascending order, beginning at 0.";
      }

      leaf type {
        type enumeration {
          enum "MPLS_SID" {
            value 1;
            description
              "The segment is specified as an MPLS label.";
          }
          enum "IPV6_SID" {
            value 2;
            description
              "The segment is specified as an IPv6 address.";
          }
          enum "IPV4_NODE_ADDRESS" {
            value 3;
            description
              "The segment is specified as an IPv4 node address with
            optional SID.";
          }
          enum "IPV6_NODE_ADDRESS" {
            value 4;
            description
              "The segment is specified as an IPv6 node address with
            optional SID.";
          }
          enum "IPV4_LOCAL_INTF_ID" {
            value 5;
            description
              "The segment is specified as an IPv4 address with a
            local interface identifier along with an .";
          }
          enum "IPV4_LOCAL_REMOTE_ADDR" {
            value 6;
            description
              "The segment is specified as an IPv4 local and remote
            address with an optional SID.";
          }
          enum "IPV6_LOCAL_INTF_ID" {
            value 7;
            description
              "The segment is specified as an IPv6 address with an
            index, along with an optional SID.";
          }
          enum "IPV6_LOCAL_REMOTE_ADDR" {
            value 8;
            description
              "The segmetn is specified as an IPv6 local and remote
            address with an optional SID.";
          }
        }
        description
          "The type of segment specified within the segment entry.";
      }

      leaf sid {
        type oc-sr:sr-sid-type;
        description
          "SID value for the segment entry, specified as an MPLS label
        or IPv6 address.";
      }

      leaf mpls-tc {
        when "../type = 'MPLS_SID'" {
          description
            "The MPLS TC bits can only be specified when the segment
          time is an MPLS label.";
        }
        type uint8 {
          range "0..7";
        }
        description
          "The MPLS TC bits used when the SID is specified as an MPLS
        label. If set to zero, the receiving system specifies the
        value of the TC bits.";
      }

      leaf mpls-bos {
        when "../type = 'MPLS_SID'" {
          description
            "The MPLS BoS bit can only be specified when the segment
          type is an MPLS label.";
        }
        type boolean;
        description
          "When this leaf is set to true the MPLS bottom-of-stack
        (BoS) bit is set in the MPLS segment. The BoS bit should
        always be set to zero by the sender.";
      }

      leaf mpls-ttl {
        when "../type = 'MPLS_SID'" {
          description
            "The MPLS TTL can only be set when the segment type is
          an MPLS label.";
        }
        type uint8;
        description
          "The MPLS time to live (TTL) to be set for the MPLS
        segment. If set to 255, the receiver specifies the
        TTL value that is used for packets sent with this
        segment in the stack.";
      }

      leaf remote-ipv4-address {
        when
          "../type = 'IPV4_NODE_ADDRESS' or ../type='../IPV4_ADDRESS_INDEX'"
            + "or ../type='IPV4_LOCAL_INTF_ID' or "
            + "../type='IPV4_LOCAL_REMOTE_ADDR'" {
          description
            "An IPv4 address can only be associated with the segment entry
          when the type of the SID is a node address, or an IPv6 address
          with an index.";
        }
        type oc-inet:ipv4-address;
        description
          "An IPv4 address specified as the remote node address. When the type
        of the segment specifies only the remote address, no other addresses
        are specified. When the type of the segment requires a local address,
        this leaf specifies the remote IPv4 address.";
      }

      leaf local-ipv4-address {
        when
          "../type = 'IPV4_LOCAL_REMOTE_ADDR'" {
          description
            "A local IPv4 address can only be specified when the segment is
          specified by the local and remote IPv4 interface addresses.";
        }
        type oc-inet:ipv4-address;
        description
          "An IPv4 address of a local adjacency that is used to identify
        the segment.";
      }

      leaf remote-ipv6-address {
        when
          "../type = 'IPV6_NODE_ADDRESS' or ../type='IPV6_ADDRESS_INDEX'"
            + "or ../type='IPV6_LOCAL_INTF_ID' or "
            + "../type='IPV6_LOCAL_REMOTE_ADDR'" {
          description
            "An IPv6 address can only be specified with a segment entry
          when the type of the SID is a node address, or an IPv6 address
          with an index.";
        }
        type oc-inet:ipv6-address;
        description
          "An IPv6 address specified as the remote node address. When the type
        of the segment specifies only the remote address, no other addresses
        are specified. When the type of the segment requires a local address,
        this leaf specifies the remote IPv6 address.";
      }

      leaf local-ipv6-address {
        when
          "../type = 'IPV6_LOCAL_REMOTE_ADDR'" {
          description
            "A local IPv6 address can only be speciifed when the segment
          is specified by the local and remote IPv6 interface addresses.";
        }
        type oc-inet:ipv6-address;
        description
          "An IPv6 address of a local adjacency that is used to identify the
        segment.";
      }

      leaf local-interface-id {
        when
          "../type = 'IPV4_LOCAL_INTF_ID' or ../type='IPV6_LOCAL_INTF_ID'" {
          description
            "A local interface identifier can only be specified when the
          type of the segment is an IPv4 address with local interface ID,
          or IPv6 address with local interface ID.";
        }
        type uint32;
        description
          "The local interface identifier to be utilised for the segment.";
        reference
          "draft-ietf-pce-segment-routing";

      }
    }  // grouping bgp-tunnel-encapsulation-attr-tunnel-subtlv-segment-state
  }  // submodule openconfig-rib-bgp-attributes