// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.33.2
// source: envoy/api/v2/cluster.proto

package apiv2

import (
	_ "github.com/cncf/xds/go/udpa/annotations"
	_ "github.com/envoyproxy/go-control-plane/envoy/annotations"
	auth "github.com/envoyproxy/go-control-plane/envoy/api/v2/auth"
	cluster "github.com/envoyproxy/go-control-plane/envoy/api/v2/cluster"
	core "github.com/envoyproxy/go-control-plane/envoy/api/v2/core"
	_type "github.com/envoyproxy/go-control-plane/envoy/type"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	anypb "google.golang.org/protobuf/types/known/anypb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Refer to :ref:`service discovery type <arch_overview_service_discovery_types>`
// for an explanation on each type.
type Cluster_DiscoveryType int32

const (
	// Refer to the :ref:`static discovery type<arch_overview_service_discovery_types_static>`
	// for an explanation.
	Cluster_STATIC Cluster_DiscoveryType = 0
	// Refer to the :ref:`strict DNS discovery
	// type<arch_overview_service_discovery_types_strict_dns>`
	// for an explanation.
	Cluster_STRICT_DNS Cluster_DiscoveryType = 1
	// Refer to the :ref:`logical DNS discovery
	// type<arch_overview_service_discovery_types_logical_dns>`
	// for an explanation.
	Cluster_LOGICAL_DNS Cluster_DiscoveryType = 2
	// Refer to the :ref:`service discovery type<arch_overview_service_discovery_types_eds>`
	// for an explanation.
	Cluster_EDS Cluster_DiscoveryType = 3
	// Refer to the :ref:`original destination discovery
	// type<arch_overview_service_discovery_types_original_destination>`
	// for an explanation.
	Cluster_ORIGINAL_DST Cluster_DiscoveryType = 4
)

// Enum value maps for Cluster_DiscoveryType.
var (
	Cluster_DiscoveryType_name = map[int32]string{
		0: "STATIC",
		1: "STRICT_DNS",
		2: "LOGICAL_DNS",
		3: "EDS",
		4: "ORIGINAL_DST",
	}
	Cluster_DiscoveryType_value = map[string]int32{
		"STATIC":       0,
		"STRICT_DNS":   1,
		"LOGICAL_DNS":  2,
		"EDS":          3,
		"ORIGINAL_DST": 4,
	}
)

func (x Cluster_DiscoveryType) Enum() *Cluster_DiscoveryType {
	p := new(Cluster_DiscoveryType)
	*p = x
	return p
}

func (x Cluster_DiscoveryType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_DiscoveryType) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[0].Descriptor()
}

func (Cluster_DiscoveryType) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[0]
}

func (x Cluster_DiscoveryType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_DiscoveryType.Descriptor instead.
func (Cluster_DiscoveryType) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 0}
}

// Refer to :ref:`load balancer type <arch_overview_load_balancing_types>` architecture
// overview section for information on each type.
type Cluster_LbPolicy int32

const (
	// Refer to the :ref:`round robin load balancing
	// policy<arch_overview_load_balancing_types_round_robin>`
	// for an explanation.
	Cluster_ROUND_ROBIN Cluster_LbPolicy = 0
	// Refer to the :ref:`least request load balancing
	// policy<arch_overview_load_balancing_types_least_request>`
	// for an explanation.
	Cluster_LEAST_REQUEST Cluster_LbPolicy = 1
	// Refer to the :ref:`ring hash load balancing
	// policy<arch_overview_load_balancing_types_ring_hash>`
	// for an explanation.
	Cluster_RING_HASH Cluster_LbPolicy = 2
	// Refer to the :ref:`random load balancing
	// policy<arch_overview_load_balancing_types_random>`
	// for an explanation.
	Cluster_RANDOM Cluster_LbPolicy = 3
	// Refer to the :ref:`original destination load balancing
	// policy<arch_overview_load_balancing_types_original_destination>`
	// for an explanation.
	//
	// .. attention::
	//
	//	**This load balancing policy is deprecated**. Use CLUSTER_PROVIDED instead.
	//
	// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
	Cluster_ORIGINAL_DST_LB Cluster_LbPolicy = 4
	// Refer to the :ref:`Maglev load balancing policy<arch_overview_load_balancing_types_maglev>`
	// for an explanation.
	Cluster_MAGLEV Cluster_LbPolicy = 5
	// This load balancer type must be specified if the configured cluster provides a cluster
	// specific load balancer. Consult the configured cluster's documentation for whether to set
	// this option or not.
	Cluster_CLUSTER_PROVIDED Cluster_LbPolicy = 6
	// [#not-implemented-hide:] Use the new :ref:`load_balancing_policy
	// <envoy_api_field_Cluster.load_balancing_policy>` field to determine the LB policy.
	// [#next-major-version: In the v3 API, we should consider deprecating the lb_policy field
	// and instead using the new load_balancing_policy field as the one and only mechanism for
	// configuring this.]
	Cluster_LOAD_BALANCING_POLICY_CONFIG Cluster_LbPolicy = 7
)

// Enum value maps for Cluster_LbPolicy.
var (
	Cluster_LbPolicy_name = map[int32]string{
		0: "ROUND_ROBIN",
		1: "LEAST_REQUEST",
		2: "RING_HASH",
		3: "RANDOM",
		4: "ORIGINAL_DST_LB",
		5: "MAGLEV",
		6: "CLUSTER_PROVIDED",
		7: "LOAD_BALANCING_POLICY_CONFIG",
	}
	Cluster_LbPolicy_value = map[string]int32{
		"ROUND_ROBIN":                  0,
		"LEAST_REQUEST":                1,
		"RING_HASH":                    2,
		"RANDOM":                       3,
		"ORIGINAL_DST_LB":              4,
		"MAGLEV":                       5,
		"CLUSTER_PROVIDED":             6,
		"LOAD_BALANCING_POLICY_CONFIG": 7,
	}
)

func (x Cluster_LbPolicy) Enum() *Cluster_LbPolicy {
	p := new(Cluster_LbPolicy)
	*p = x
	return p
}

func (x Cluster_LbPolicy) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_LbPolicy) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[1].Descriptor()
}

func (Cluster_LbPolicy) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[1]
}

func (x Cluster_LbPolicy) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_LbPolicy.Descriptor instead.
func (Cluster_LbPolicy) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 1}
}

// When V4_ONLY is selected, the DNS resolver will only perform a lookup for
// addresses in the IPv4 family. If V6_ONLY is selected, the DNS resolver will
// only perform a lookup for addresses in the IPv6 family. If AUTO is
// specified, the DNS resolver will first perform a lookup for addresses in
// the IPv6 family and fallback to a lookup for addresses in the IPv4 family.
// For cluster types other than
// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>` and
// :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
// this setting is
// ignored.
type Cluster_DnsLookupFamily int32

const (
	Cluster_AUTO    Cluster_DnsLookupFamily = 0
	Cluster_V4_ONLY Cluster_DnsLookupFamily = 1
	Cluster_V6_ONLY Cluster_DnsLookupFamily = 2
)

// Enum value maps for Cluster_DnsLookupFamily.
var (
	Cluster_DnsLookupFamily_name = map[int32]string{
		0: "AUTO",
		1: "V4_ONLY",
		2: "V6_ONLY",
	}
	Cluster_DnsLookupFamily_value = map[string]int32{
		"AUTO":    0,
		"V4_ONLY": 1,
		"V6_ONLY": 2,
	}
)

func (x Cluster_DnsLookupFamily) Enum() *Cluster_DnsLookupFamily {
	p := new(Cluster_DnsLookupFamily)
	*p = x
	return p
}

func (x Cluster_DnsLookupFamily) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_DnsLookupFamily) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[2].Descriptor()
}

func (Cluster_DnsLookupFamily) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[2]
}

func (x Cluster_DnsLookupFamily) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_DnsLookupFamily.Descriptor instead.
func (Cluster_DnsLookupFamily) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 2}
}

type Cluster_ClusterProtocolSelection int32

const (
	// Cluster can only operate on one of the possible upstream protocols (HTTP1.1, HTTP2).
	// If :ref:`http2_protocol_options <envoy_api_field_Cluster.http2_protocol_options>` are
	// present, HTTP2 will be used, otherwise HTTP1.1 will be used.
	Cluster_USE_CONFIGURED_PROTOCOL Cluster_ClusterProtocolSelection = 0
	// Use HTTP1.1 or HTTP2, depending on which one is used on the downstream connection.
	Cluster_USE_DOWNSTREAM_PROTOCOL Cluster_ClusterProtocolSelection = 1
)

// Enum value maps for Cluster_ClusterProtocolSelection.
var (
	Cluster_ClusterProtocolSelection_name = map[int32]string{
		0: "USE_CONFIGURED_PROTOCOL",
		1: "USE_DOWNSTREAM_PROTOCOL",
	}
	Cluster_ClusterProtocolSelection_value = map[string]int32{
		"USE_CONFIGURED_PROTOCOL": 0,
		"USE_DOWNSTREAM_PROTOCOL": 1,
	}
)

func (x Cluster_ClusterProtocolSelection) Enum() *Cluster_ClusterProtocolSelection {
	p := new(Cluster_ClusterProtocolSelection)
	*p = x
	return p
}

func (x Cluster_ClusterProtocolSelection) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_ClusterProtocolSelection) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[3].Descriptor()
}

func (Cluster_ClusterProtocolSelection) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[3]
}

func (x Cluster_ClusterProtocolSelection) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_ClusterProtocolSelection.Descriptor instead.
func (Cluster_ClusterProtocolSelection) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 3}
}

// If NO_FALLBACK is selected, a result
// equivalent to no healthy hosts is reported. If ANY_ENDPOINT is selected,
// any cluster endpoint may be returned (subject to policy, health checks,
// etc). If DEFAULT_SUBSET is selected, load balancing is performed over the
// endpoints matching the values from the default_subset field.
type Cluster_LbSubsetConfig_LbSubsetFallbackPolicy int32

const (
	Cluster_LbSubsetConfig_NO_FALLBACK    Cluster_LbSubsetConfig_LbSubsetFallbackPolicy = 0
	Cluster_LbSubsetConfig_ANY_ENDPOINT   Cluster_LbSubsetConfig_LbSubsetFallbackPolicy = 1
	Cluster_LbSubsetConfig_DEFAULT_SUBSET Cluster_LbSubsetConfig_LbSubsetFallbackPolicy = 2
)

// Enum value maps for Cluster_LbSubsetConfig_LbSubsetFallbackPolicy.
var (
	Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_name = map[int32]string{
		0: "NO_FALLBACK",
		1: "ANY_ENDPOINT",
		2: "DEFAULT_SUBSET",
	}
	Cluster_LbSubsetConfig_LbSubsetFallbackPolicy_value = map[string]int32{
		"NO_FALLBACK":    0,
		"ANY_ENDPOINT":   1,
		"DEFAULT_SUBSET": 2,
	}
)

func (x Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) Enum() *Cluster_LbSubsetConfig_LbSubsetFallbackPolicy {
	p := new(Cluster_LbSubsetConfig_LbSubsetFallbackPolicy)
	*p = x
	return p
}

func (x Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[4].Descriptor()
}

func (Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[4]
}

func (x Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_LbSubsetConfig_LbSubsetFallbackPolicy.Descriptor instead.
func (Cluster_LbSubsetConfig_LbSubsetFallbackPolicy) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 3, 0}
}

// Allows to override top level fallback policy per selector.
type Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy int32

const (
	// If NOT_DEFINED top level config fallback policy is used instead.
	Cluster_LbSubsetConfig_LbSubsetSelector_NOT_DEFINED Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 0
	// If NO_FALLBACK is selected, a result equivalent to no healthy hosts is reported.
	Cluster_LbSubsetConfig_LbSubsetSelector_NO_FALLBACK Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 1
	// If ANY_ENDPOINT is selected, any cluster endpoint may be returned
	// (subject to policy, health checks, etc).
	Cluster_LbSubsetConfig_LbSubsetSelector_ANY_ENDPOINT Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 2
	// If DEFAULT_SUBSET is selected, load balancing is performed over the
	// endpoints matching the values from the default_subset field.
	Cluster_LbSubsetConfig_LbSubsetSelector_DEFAULT_SUBSET Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 3
	// If KEYS_SUBSET is selected, subset selector matching is performed again with metadata
	// keys reduced to
	// :ref:`fallback_keys_subset<envoy_api_field_Cluster.LbSubsetConfig.LbSubsetSelector.fallback_keys_subset>`.
	// It allows for a fallback to a different, less specific selector if some of the keys of
	// the selector are considered optional.
	Cluster_LbSubsetConfig_LbSubsetSelector_KEYS_SUBSET Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy = 4
)

// Enum value maps for Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy.
var (
	Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_name = map[int32]string{
		0: "NOT_DEFINED",
		1: "NO_FALLBACK",
		2: "ANY_ENDPOINT",
		3: "DEFAULT_SUBSET",
		4: "KEYS_SUBSET",
	}
	Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy_value = map[string]int32{
		"NOT_DEFINED":    0,
		"NO_FALLBACK":    1,
		"ANY_ENDPOINT":   2,
		"DEFAULT_SUBSET": 3,
		"KEYS_SUBSET":    4,
	}
)

func (x Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) Enum() *Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy {
	p := new(Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy)
	*p = x
	return p
}

func (x Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[5].Descriptor()
}

func (Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[5]
}

func (x Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy.Descriptor instead.
func (Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 3, 0, 0}
}

// The hash function used to hash hosts onto the ketama ring.
type Cluster_RingHashLbConfig_HashFunction int32

const (
	// Use `xxHash <https://github.com/Cyan4973/xxHash>`_, this is the default hash function.
	Cluster_RingHashLbConfig_XX_HASH Cluster_RingHashLbConfig_HashFunction = 0
	// Use `MurmurHash2 <https://sites.google.com/site/murmurhash/>`_, this is compatible with
	// std:hash<string> in GNU libstdc++ 3.4.20 or above. This is typically the case when compiled
	// on Linux and not macOS.
	Cluster_RingHashLbConfig_MURMUR_HASH_2 Cluster_RingHashLbConfig_HashFunction = 1
)

// Enum value maps for Cluster_RingHashLbConfig_HashFunction.
var (
	Cluster_RingHashLbConfig_HashFunction_name = map[int32]string{
		0: "XX_HASH",
		1: "MURMUR_HASH_2",
	}
	Cluster_RingHashLbConfig_HashFunction_value = map[string]int32{
		"XX_HASH":       0,
		"MURMUR_HASH_2": 1,
	}
)

func (x Cluster_RingHashLbConfig_HashFunction) Enum() *Cluster_RingHashLbConfig_HashFunction {
	p := new(Cluster_RingHashLbConfig_HashFunction)
	*p = x
	return p
}

func (x Cluster_RingHashLbConfig_HashFunction) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (Cluster_RingHashLbConfig_HashFunction) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_api_v2_cluster_proto_enumTypes[6].Descriptor()
}

func (Cluster_RingHashLbConfig_HashFunction) Type() protoreflect.EnumType {
	return &file_envoy_api_v2_cluster_proto_enumTypes[6]
}

func (x Cluster_RingHashLbConfig_HashFunction) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use Cluster_RingHashLbConfig_HashFunction.Descriptor instead.
func (Cluster_RingHashLbConfig_HashFunction) EnumDescriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 5, 0}
}

// Configuration for a single upstream cluster.
// [#next-free-field: 48]
type Cluster struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configuration to use different transport sockets for different endpoints.
	// The entry of *envoy.transport_socket_match* in the
	// :ref:`LbEndpoint.Metadata <envoy_api_field_endpoint.LbEndpoint.metadata>`
	// is used to match against the transport sockets as they appear in the list. The first
	// :ref:`match <envoy_api_msg_Cluster.TransportSocketMatch>` is used.
	// For example, with the following match
	//
	// .. code-block:: yaml
	//
	//	transport_socket_matches:
	//	- name: "enableMTLS"
	//	  match:
	//	    acceptMTLS: true
	//	  transport_socket:
	//	    name: envoy.transport_sockets.tls
	//	    config: { ... } # tls socket configuration
	//	- name: "defaultToPlaintext"
	//	  match: {}
	//	  transport_socket:
	//	    name: envoy.transport_sockets.raw_buffer
	//
	// Connections to the endpoints whose metadata value under *envoy.transport_socket_match*
	// having "acceptMTLS"/"true" key/value pair use the "enableMTLS" socket configuration.
	//
	// If a :ref:`socket match <envoy_api_msg_Cluster.TransportSocketMatch>` with empty match
	// criteria is provided, that always match any endpoint. For example, the "defaultToPlaintext"
	// socket match in case above.
	//
	// If an endpoint metadata's value under *envoy.transport_socket_match* does not match any
	// *TransportSocketMatch*, socket configuration fallbacks to use the *tls_context* or
	// *transport_socket* specified in this cluster.
	//
	// This field allows gradual and flexible transport socket configuration changes.
	//
	// The metadata of endpoints in EDS can indicate transport socket capabilities. For example,
	// an endpoint's metadata can have two key value pairs as "acceptMTLS": "true",
	// "acceptPlaintext": "true". While some other endpoints, only accepting plaintext traffic
	// has "acceptPlaintext": "true" metadata information.
	//
	// Then the xDS server can configure the CDS to a client, Envoy A, to send mutual TLS
	// traffic for endpoints with "acceptMTLS": "true", by adding a corresponding
	// *TransportSocketMatch* in this field. Other client Envoys receive CDS without
	// *transport_socket_match* set, and still send plain text traffic to the same cluster.
	//
	// [#comment:TODO(incfly): add a detailed architecture doc on intended usage.]
	TransportSocketMatches []*Cluster_TransportSocketMatch `protobuf:"bytes,43,rep,name=transport_socket_matches,json=transportSocketMatches,proto3" json:"transport_socket_matches,omitempty"`
	// Supplies the name of the cluster which must be unique across all clusters.
	// The cluster name is used when emitting
	// :ref:`statistics <config_cluster_manager_cluster_stats>` if :ref:`alt_stat_name
	// <envoy_api_field_Cluster.alt_stat_name>` is not provided.
	// Any “:“ in the cluster name will be converted to “_“ when emitting statistics.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// An optional alternative to the cluster name to be used while emitting stats.
	// Any “:“ in the name will be converted to “_“ when emitting statistics. This should not be
	// confused with :ref:`Router Filter Header
	// <config_http_filters_router_x-envoy-upstream-alt-stat-name>`.
	AltStatName string `protobuf:"bytes,28,opt,name=alt_stat_name,json=altStatName,proto3" json:"alt_stat_name,omitempty"`
	// Types that are valid to be assigned to ClusterDiscoveryType:
	//
	//	*Cluster_Type
	//	*Cluster_ClusterType
	ClusterDiscoveryType isCluster_ClusterDiscoveryType `protobuf_oneof:"cluster_discovery_type"`
	// Configuration to use for EDS updates for the Cluster.
	EdsClusterConfig *Cluster_EdsClusterConfig `protobuf:"bytes,3,opt,name=eds_cluster_config,json=edsClusterConfig,proto3" json:"eds_cluster_config,omitempty"`
	// The timeout for new network connections to hosts in the cluster.
	ConnectTimeout *durationpb.Duration `protobuf:"bytes,4,opt,name=connect_timeout,json=connectTimeout,proto3" json:"connect_timeout,omitempty"`
	// Soft limit on size of the cluster’s connections read and write buffers. If
	// unspecified, an implementation defined default is applied (1MiB).
	PerConnectionBufferLimitBytes *wrapperspb.UInt32Value `protobuf:"bytes,5,opt,name=per_connection_buffer_limit_bytes,json=perConnectionBufferLimitBytes,proto3" json:"per_connection_buffer_limit_bytes,omitempty"`
	// The :ref:`load balancer type <arch_overview_load_balancing_types>` to use
	// when picking a host in the cluster.
	LbPolicy Cluster_LbPolicy `protobuf:"varint,6,opt,name=lb_policy,json=lbPolicy,proto3,enum=envoy.api.v2.Cluster_LbPolicy" json:"lb_policy,omitempty"`
	// If the service discovery type is
	// :ref:`STATIC<envoy_api_enum_value_Cluster.DiscoveryType.STATIC>`,
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
	// or :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
	// then hosts is required.
	//
	// .. attention::
	//
	//	**This field is deprecated**. Set the
	//	:ref:`load_assignment<envoy_api_field_Cluster.load_assignment>` field instead.
	//
	// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
	Hosts []*core.Address `protobuf:"bytes,7,rep,name=hosts,proto3" json:"hosts,omitempty"`
	// Setting this is required for specifying members of
	// :ref:`STATIC<envoy_api_enum_value_Cluster.DiscoveryType.STATIC>`,
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
	// or :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>` clusters.
	// This field supersedes the *hosts* field in the v2 API.
	//
	// .. attention::
	//
	//	Setting this allows non-EDS cluster types to contain embedded EDS equivalent
	//	:ref:`endpoint assignments<envoy_api_msg_ClusterLoadAssignment>`.
	LoadAssignment *ClusterLoadAssignment `protobuf:"bytes,33,opt,name=load_assignment,json=loadAssignment,proto3" json:"load_assignment,omitempty"`
	// Optional :ref:`active health checking <arch_overview_health_checking>`
	// configuration for the cluster. If no
	// configuration is specified no health checking will be done and all cluster
	// members will be considered healthy at all times.
	HealthChecks []*core.HealthCheck `protobuf:"bytes,8,rep,name=health_checks,json=healthChecks,proto3" json:"health_checks,omitempty"`
	// Optional maximum requests for a single upstream connection. This parameter
	// is respected by both the HTTP/1.1 and HTTP/2 connection pool
	// implementations. If not specified, there is no limit. Setting this
	// parameter to 1 will effectively disable keep alive.
	MaxRequestsPerConnection *wrapperspb.UInt32Value `protobuf:"bytes,9,opt,name=max_requests_per_connection,json=maxRequestsPerConnection,proto3" json:"max_requests_per_connection,omitempty"`
	// Optional :ref:`circuit breaking <arch_overview_circuit_break>` for the cluster.
	CircuitBreakers *cluster.CircuitBreakers `protobuf:"bytes,10,opt,name=circuit_breakers,json=circuitBreakers,proto3" json:"circuit_breakers,omitempty"`
	// The TLS configuration for connections to the upstream cluster.
	//
	// .. attention::
	//
	//	**This field is deprecated**. Use `transport_socket` with name `tls` instead. If both are
	//	set, `transport_socket` takes priority.
	//
	// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
	TlsContext *auth.UpstreamTlsContext `protobuf:"bytes,11,opt,name=tls_context,json=tlsContext,proto3" json:"tls_context,omitempty"`
	// HTTP protocol options that are applied only to upstream HTTP connections.
	// These options apply to all HTTP versions.
	UpstreamHttpProtocolOptions *core.UpstreamHttpProtocolOptions `protobuf:"bytes,46,opt,name=upstream_http_protocol_options,json=upstreamHttpProtocolOptions,proto3" json:"upstream_http_protocol_options,omitempty"`
	// Additional options when handling HTTP requests upstream. These options will be applicable to
	// both HTTP1 and HTTP2 requests.
	CommonHttpProtocolOptions *core.HttpProtocolOptions `protobuf:"bytes,29,opt,name=common_http_protocol_options,json=commonHttpProtocolOptions,proto3" json:"common_http_protocol_options,omitempty"`
	// Additional options when handling HTTP1 requests.
	HttpProtocolOptions *core.Http1ProtocolOptions `protobuf:"bytes,13,opt,name=http_protocol_options,json=httpProtocolOptions,proto3" json:"http_protocol_options,omitempty"`
	// Even if default HTTP2 protocol options are desired, this field must be
	// set so that Envoy will assume that the upstream supports HTTP/2 when
	// making new HTTP connection pool connections. Currently, Envoy only
	// supports prior knowledge for upstream connections. Even if TLS is used
	// with ALPN, `http2_protocol_options` must be specified. As an aside this allows HTTP/2
	// connections to happen over plain text.
	Http2ProtocolOptions *core.Http2ProtocolOptions `protobuf:"bytes,14,opt,name=http2_protocol_options,json=http2ProtocolOptions,proto3" json:"http2_protocol_options,omitempty"`
	// The extension_protocol_options field is used to provide extension-specific protocol options
	// for upstream connections. The key should match the extension filter name, such as
	// "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
	// specific options.
	//
	// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
	ExtensionProtocolOptions map[string]*structpb.Struct `protobuf:"bytes,35,rep,name=extension_protocol_options,json=extensionProtocolOptions,proto3" json:"extension_protocol_options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// The extension_protocol_options field is used to provide extension-specific protocol options
	// for upstream connections. The key should match the extension filter name, such as
	// "envoy.filters.network.thrift_proxy". See the extension's documentation for details on
	// specific options.
	TypedExtensionProtocolOptions map[string]*anypb.Any `protobuf:"bytes,36,rep,name=typed_extension_protocol_options,json=typedExtensionProtocolOptions,proto3" json:"typed_extension_protocol_options,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// If the DNS refresh rate is specified and the cluster type is either
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
	// or :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
	// this value is used as the cluster’s DNS refresh
	// rate. The value configured must be at least 1ms. If this setting is not specified, the
	// value defaults to 5000ms. For cluster types other than
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
	// and :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`
	// this setting is ignored.
	DnsRefreshRate *durationpb.Duration `protobuf:"bytes,16,opt,name=dns_refresh_rate,json=dnsRefreshRate,proto3" json:"dns_refresh_rate,omitempty"`
	// If the DNS failure refresh rate is specified and the cluster type is either
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
	// or :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
	// this is used as the cluster’s DNS refresh rate when requests are failing. If this setting is
	// not specified, the failure refresh rate defaults to the DNS refresh rate. For cluster types
	// other than :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>` and
	// :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>` this setting is
	// ignored.
	DnsFailureRefreshRate *Cluster_RefreshRate `protobuf:"bytes,44,opt,name=dns_failure_refresh_rate,json=dnsFailureRefreshRate,proto3" json:"dns_failure_refresh_rate,omitempty"`
	// Optional configuration for setting cluster's DNS refresh rate. If the value is set to true,
	// cluster's DNS refresh rate will be set to resource record's TTL which comes from DNS
	// resolution.
	RespectDnsTtl bool `protobuf:"varint,39,opt,name=respect_dns_ttl,json=respectDnsTtl,proto3" json:"respect_dns_ttl,omitempty"`
	// The DNS IP address resolution policy. If this setting is not specified, the
	// value defaults to
	// :ref:`AUTO<envoy_api_enum_value_Cluster.DnsLookupFamily.AUTO>`.
	DnsLookupFamily Cluster_DnsLookupFamily `protobuf:"varint,17,opt,name=dns_lookup_family,json=dnsLookupFamily,proto3,enum=envoy.api.v2.Cluster_DnsLookupFamily" json:"dns_lookup_family,omitempty"`
	// If DNS resolvers are specified and the cluster type is either
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`,
	// or :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`,
	// this value is used to specify the cluster’s dns resolvers.
	// If this setting is not specified, the value defaults to the default
	// resolver, which uses /etc/resolv.conf for configuration. For cluster types
	// other than
	// :ref:`STRICT_DNS<envoy_api_enum_value_Cluster.DiscoveryType.STRICT_DNS>`
	// and :ref:`LOGICAL_DNS<envoy_api_enum_value_Cluster.DiscoveryType.LOGICAL_DNS>`
	// this setting is ignored.
	// Setting this value causes failure if the
	// “envoy.restart_features.use_apple_api_for_dns_lookups“ runtime value is true during
	// server startup. Apple's API only allows overriding DNS resolvers via system settings.
	DnsResolvers []*core.Address `protobuf:"bytes,18,rep,name=dns_resolvers,json=dnsResolvers,proto3" json:"dns_resolvers,omitempty"`
	// [#next-major-version: Reconcile DNS options in a single message.]
	// Always use TCP queries instead of UDP queries for DNS lookups.
	// Setting this value causes failure if the
	// “envoy.restart_features.use_apple_api_for_dns_lookups“ runtime value is true during
	// server startup. Apple' API only uses UDP for DNS resolution.
	UseTcpForDnsLookups bool `protobuf:"varint,45,opt,name=use_tcp_for_dns_lookups,json=useTcpForDnsLookups,proto3" json:"use_tcp_for_dns_lookups,omitempty"`
	// If specified, outlier detection will be enabled for this upstream cluster.
	// Each of the configuration values can be overridden via
	// :ref:`runtime values <config_cluster_manager_cluster_runtime_outlier_detection>`.
	OutlierDetection *cluster.OutlierDetection `protobuf:"bytes,19,opt,name=outlier_detection,json=outlierDetection,proto3" json:"outlier_detection,omitempty"`
	// The interval for removing stale hosts from a cluster type
	// :ref:`ORIGINAL_DST<envoy_api_enum_value_Cluster.DiscoveryType.ORIGINAL_DST>`.
	// Hosts are considered stale if they have not been used
	// as upstream destinations during this interval. New hosts are added
	// to original destination clusters on demand as new connections are
	// redirected to Envoy, causing the number of hosts in the cluster to
	// grow over time. Hosts that are not stale (they are actively used as
	// destinations) are kept in the cluster, which allows connections to
	// them remain open, saving the latency that would otherwise be spent
	// on opening new connections. If this setting is not specified, the
	// value defaults to 5000ms. For cluster types other than
	// :ref:`ORIGINAL_DST<envoy_api_enum_value_Cluster.DiscoveryType.ORIGINAL_DST>`
	// this setting is ignored.
	CleanupInterval *durationpb.Duration `protobuf:"bytes,20,opt,name=cleanup_interval,json=cleanupInterval,proto3" json:"cleanup_interval,omitempty"`
	// Optional configuration used to bind newly established upstream connections.
	// This overrides any bind_config specified in the bootstrap proto.
	// If the address and port are empty, no bind will be performed.
	UpstreamBindConfig *core.BindConfig `protobuf:"bytes,21,opt,name=upstream_bind_config,json=upstreamBindConfig,proto3" json:"upstream_bind_config,omitempty"`
	// Configuration for load balancing subsetting.
	LbSubsetConfig *Cluster_LbSubsetConfig `protobuf:"bytes,22,opt,name=lb_subset_config,json=lbSubsetConfig,proto3" json:"lb_subset_config,omitempty"`
	// Optional configuration for the load balancing algorithm selected by
	// LbPolicy. Currently only
	// :ref:`RING_HASH<envoy_api_enum_value_Cluster.LbPolicy.RING_HASH>` and
	// :ref:`LEAST_REQUEST<envoy_api_enum_value_Cluster.LbPolicy.LEAST_REQUEST>`
	// has additional configuration options.
	// Specifying ring_hash_lb_config or least_request_lb_config without setting the corresponding
	// LbPolicy will generate an error at runtime.
	//
	// Types that are valid to be assigned to LbConfig:
	//
	//	*Cluster_RingHashLbConfig_
	//	*Cluster_OriginalDstLbConfig_
	//	*Cluster_LeastRequestLbConfig_
	LbConfig isCluster_LbConfig `protobuf_oneof:"lb_config"`
	// Common configuration for all load balancer implementations.
	CommonLbConfig *Cluster_CommonLbConfig `protobuf:"bytes,27,opt,name=common_lb_config,json=commonLbConfig,proto3" json:"common_lb_config,omitempty"`
	// Optional custom transport socket implementation to use for upstream connections.
	// To setup TLS, set a transport socket with name `tls` and
	// :ref:`UpstreamTlsContexts <envoy_api_msg_auth.UpstreamTlsContext>` in the `typed_config`.
	// If no transport socket configuration is specified, new connections
	// will be set up with plaintext.
	TransportSocket *core.TransportSocket `protobuf:"bytes,24,opt,name=transport_socket,json=transportSocket,proto3" json:"transport_socket,omitempty"`
	// The Metadata field can be used to provide additional information about the
	// cluster. It can be used for stats, logging, and varying filter behavior.
	// Fields should use reverse DNS notation to denote which entity within Envoy
	// will need the information. For instance, if the metadata is intended for
	// the Router filter, the filter name should be specified as *envoy.filters.http.router*.
	Metadata *core.Metadata `protobuf:"bytes,25,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// Determines how Envoy selects the protocol used to speak to upstream hosts.
	ProtocolSelection Cluster_ClusterProtocolSelection `protobuf:"varint,26,opt,name=protocol_selection,json=protocolSelection,proto3,enum=envoy.api.v2.Cluster_ClusterProtocolSelection" json:"protocol_selection,omitempty"`
	// Optional options for upstream connections.
	UpstreamConnectionOptions *UpstreamConnectionOptions `protobuf:"bytes,30,opt,name=upstream_connection_options,json=upstreamConnectionOptions,proto3" json:"upstream_connection_options,omitempty"`
	// If an upstream host becomes unhealthy (as determined by the configured health checks
	// or outlier detection), immediately close all connections to the failed host.
	//
	// .. note::
	//
	//	This is currently only supported for connections created by tcp_proxy.
	//
	// .. note::
	//
	//	The current implementation of this feature closes all connections immediately when
	//	the unhealthy status is detected. If there are a large number of connections open
	//	to an upstream host that becomes unhealthy, Envoy may spend a substantial amount of
	//	time exclusively closing these connections, and not processing any other traffic.
	CloseConnectionsOnHostHealthFailure bool `protobuf:"varint,31,opt,name=close_connections_on_host_health_failure,json=closeConnectionsOnHostHealthFailure,proto3" json:"close_connections_on_host_health_failure,omitempty"`
	// If set to true, Envoy will ignore the health value of a host when processing its removal
	// from service discovery. This means that if active health checking is used, Envoy will *not*
	// wait for the endpoint to go unhealthy before removing it.
	DrainConnectionsOnHostRemoval bool `protobuf:"varint,32,opt,name=drain_connections_on_host_removal,json=drainConnectionsOnHostRemoval,proto3" json:"drain_connections_on_host_removal,omitempty"`
	// An (optional) network filter chain, listed in the order the filters should be applied.
	// The chain will be applied to all outgoing connections that Envoy makes to the upstream
	// servers of this cluster.
	Filters []*cluster.Filter `protobuf:"bytes,40,rep,name=filters,proto3" json:"filters,omitempty"`
	// [#not-implemented-hide:] New mechanism for LB policy configuration. Used only if the
	// :ref:`lb_policy<envoy_api_field_Cluster.lb_policy>` field has the value
	// :ref:`LOAD_BALANCING_POLICY_CONFIG<envoy_api_enum_value_Cluster.LbPolicy.LOAD_BALANCING_POLICY_CONFIG>`.
	LoadBalancingPolicy *LoadBalancingPolicy `protobuf:"bytes,41,opt,name=load_balancing_policy,json=loadBalancingPolicy,proto3" json:"load_balancing_policy,omitempty"`
	// [#not-implemented-hide:]
	// If present, tells the client where to send load reports via LRS. If not present, the
	// client will fall back to a client-side default, which may be either (a) don't send any
	// load reports or (b) send load reports for all clusters to a single default server
	// (which may be configured in the bootstrap file).
	//
	// Note that if multiple clusters point to the same LRS server, the client may choose to
	// create a separate stream for each cluster or it may choose to coalesce the data for
	// multiple clusters onto a single stream. Either way, the client must make sure to send
	// the data for any given cluster on no more than one stream.
	//
	// [#next-major-version: In the v3 API, we should consider restructuring this somehow,
	// maybe by allowing LRS to go on the ADS stream, or maybe by moving some of the negotiation
	// from the LRS stream here.]
	LrsServer *core.ConfigSource `protobuf:"bytes,42,opt,name=lrs_server,json=lrsServer,proto3" json:"lrs_server,omitempty"`
	// If track_timeout_budgets is true, the :ref:`timeout budget histograms
	// <config_cluster_manager_cluster_stats_timeout_budgets>` will be published for each
	// request. These show what percentage of a request's per try and global timeout was used. A value
	// of 0 would indicate that none of the timeout was used or that the timeout was infinite. A value
	// of 100 would indicate that the request took the entirety of the timeout given to it.
	TrackTimeoutBudgets bool `protobuf:"varint,47,opt,name=track_timeout_budgets,json=trackTimeoutBudgets,proto3" json:"track_timeout_budgets,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *Cluster) Reset() {
	*x = Cluster{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster) ProtoMessage() {}

func (x *Cluster) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster.ProtoReflect.Descriptor instead.
func (*Cluster) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0}
}

func (x *Cluster) GetTransportSocketMatches() []*Cluster_TransportSocketMatch {
	if x != nil {
		return x.TransportSocketMatches
	}
	return nil
}

func (x *Cluster) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Cluster) GetAltStatName() string {
	if x != nil {
		return x.AltStatName
	}
	return ""
}

func (x *Cluster) GetClusterDiscoveryType() isCluster_ClusterDiscoveryType {
	if x != nil {
		return x.ClusterDiscoveryType
	}
	return nil
}

func (x *Cluster) GetType() Cluster_DiscoveryType {
	if x != nil {
		if x, ok := x.ClusterDiscoveryType.(*Cluster_Type); ok {
			return x.Type
		}
	}
	return Cluster_STATIC
}

func (x *Cluster) GetClusterType() *Cluster_CustomClusterType {
	if x != nil {
		if x, ok := x.ClusterDiscoveryType.(*Cluster_ClusterType); ok {
			return x.ClusterType
		}
	}
	return nil
}

func (x *Cluster) GetEdsClusterConfig() *Cluster_EdsClusterConfig {
	if x != nil {
		return x.EdsClusterConfig
	}
	return nil
}

func (x *Cluster) GetConnectTimeout() *durationpb.Duration {
	if x != nil {
		return x.ConnectTimeout
	}
	return nil
}

func (x *Cluster) GetPerConnectionBufferLimitBytes() *wrapperspb.UInt32Value {
	if x != nil {
		return x.PerConnectionBufferLimitBytes
	}
	return nil
}

func (x *Cluster) GetLbPolicy() Cluster_LbPolicy {
	if x != nil {
		return x.LbPolicy
	}
	return Cluster_ROUND_ROBIN
}

// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
func (x *Cluster) GetHosts() []*core.Address {
	if x != nil {
		return x.Hosts
	}
	return nil
}

func (x *Cluster) GetLoadAssignment() *ClusterLoadAssignment {
	if x != nil {
		return x.LoadAssignment
	}
	return nil
}

func (x *Cluster) GetHealthChecks() []*core.HealthCheck {
	if x != nil {
		return x.HealthChecks
	}
	return nil
}

func (x *Cluster) GetMaxRequestsPerConnection() *wrapperspb.UInt32Value {
	if x != nil {
		return x.MaxRequestsPerConnection
	}
	return nil
}

func (x *Cluster) GetCircuitBreakers() *cluster.CircuitBreakers {
	if x != nil {
		return x.CircuitBreakers
	}
	return nil
}

// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
func (x *Cluster) GetTlsContext() *auth.UpstreamTlsContext {
	if x != nil {
		return x.TlsContext
	}
	return nil
}

func (x *Cluster) GetUpstreamHttpProtocolOptions() *core.UpstreamHttpProtocolOptions {
	if x != nil {
		return x.UpstreamHttpProtocolOptions
	}
	return nil
}

func (x *Cluster) GetCommonHttpProtocolOptions() *core.HttpProtocolOptions {
	if x != nil {
		return x.CommonHttpProtocolOptions
	}
	return nil
}

func (x *Cluster) GetHttpProtocolOptions() *core.Http1ProtocolOptions {
	if x != nil {
		return x.HttpProtocolOptions
	}
	return nil
}

func (x *Cluster) GetHttp2ProtocolOptions() *core.Http2ProtocolOptions {
	if x != nil {
		return x.Http2ProtocolOptions
	}
	return nil
}

// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
func (x *Cluster) GetExtensionProtocolOptions() map[string]*structpb.Struct {
	if x != nil {
		return x.ExtensionProtocolOptions
	}
	return nil
}

func (x *Cluster) GetTypedExtensionProtocolOptions() map[string]*anypb.Any {
	if x != nil {
		return x.TypedExtensionProtocolOptions
	}
	return nil
}

func (x *Cluster) GetDnsRefreshRate() *durationpb.Duration {
	if x != nil {
		return x.DnsRefreshRate
	}
	return nil
}

func (x *Cluster) GetDnsFailureRefreshRate() *Cluster_RefreshRate {
	if x != nil {
		return x.DnsFailureRefreshRate
	}
	return nil
}

func (x *Cluster) GetRespectDnsTtl() bool {
	if x != nil {
		return x.RespectDnsTtl
	}
	return false
}

func (x *Cluster) GetDnsLookupFamily() Cluster_DnsLookupFamily {
	if x != nil {
		return x.DnsLookupFamily
	}
	return Cluster_AUTO
}

func (x *Cluster) GetDnsResolvers() []*core.Address {
	if x != nil {
		return x.DnsResolvers
	}
	return nil
}

func (x *Cluster) GetUseTcpForDnsLookups() bool {
	if x != nil {
		return x.UseTcpForDnsLookups
	}
	return false
}

func (x *Cluster) GetOutlierDetection() *cluster.OutlierDetection {
	if x != nil {
		return x.OutlierDetection
	}
	return nil
}

func (x *Cluster) GetCleanupInterval() *durationpb.Duration {
	if x != nil {
		return x.CleanupInterval
	}
	return nil
}

func (x *Cluster) GetUpstreamBindConfig() *core.BindConfig {
	if x != nil {
		return x.UpstreamBindConfig
	}
	return nil
}

func (x *Cluster) GetLbSubsetConfig() *Cluster_LbSubsetConfig {
	if x != nil {
		return x.LbSubsetConfig
	}
	return nil
}

func (x *Cluster) GetLbConfig() isCluster_LbConfig {
	if x != nil {
		return x.LbConfig
	}
	return nil
}

func (x *Cluster) GetRingHashLbConfig() *Cluster_RingHashLbConfig {
	if x != nil {
		if x, ok := x.LbConfig.(*Cluster_RingHashLbConfig_); ok {
			return x.RingHashLbConfig
		}
	}
	return nil
}

func (x *Cluster) GetOriginalDstLbConfig() *Cluster_OriginalDstLbConfig {
	if x != nil {
		if x, ok := x.LbConfig.(*Cluster_OriginalDstLbConfig_); ok {
			return x.OriginalDstLbConfig
		}
	}
	return nil
}

func (x *Cluster) GetLeastRequestLbConfig() *Cluster_LeastRequestLbConfig {
	if x != nil {
		if x, ok := x.LbConfig.(*Cluster_LeastRequestLbConfig_); ok {
			return x.LeastRequestLbConfig
		}
	}
	return nil
}

func (x *Cluster) GetCommonLbConfig() *Cluster_CommonLbConfig {
	if x != nil {
		return x.CommonLbConfig
	}
	return nil
}

func (x *Cluster) GetTransportSocket() *core.TransportSocket {
	if x != nil {
		return x.TransportSocket
	}
	return nil
}

func (x *Cluster) GetMetadata() *core.Metadata {
	if x != nil {
		return x.Metadata
	}
	return nil
}

func (x *Cluster) GetProtocolSelection() Cluster_ClusterProtocolSelection {
	if x != nil {
		return x.ProtocolSelection
	}
	return Cluster_USE_CONFIGURED_PROTOCOL
}

func (x *Cluster) GetUpstreamConnectionOptions() *UpstreamConnectionOptions {
	if x != nil {
		return x.UpstreamConnectionOptions
	}
	return nil
}

func (x *Cluster) GetCloseConnectionsOnHostHealthFailure() bool {
	if x != nil {
		return x.CloseConnectionsOnHostHealthFailure
	}
	return false
}

func (x *Cluster) GetDrainConnectionsOnHostRemoval() bool {
	if x != nil {
		return x.DrainConnectionsOnHostRemoval
	}
	return false
}

func (x *Cluster) GetFilters() []*cluster.Filter {
	if x != nil {
		return x.Filters
	}
	return nil
}

func (x *Cluster) GetLoadBalancingPolicy() *LoadBalancingPolicy {
	if x != nil {
		return x.LoadBalancingPolicy
	}
	return nil
}

func (x *Cluster) GetLrsServer() *core.ConfigSource {
	if x != nil {
		return x.LrsServer
	}
	return nil
}

func (x *Cluster) GetTrackTimeoutBudgets() bool {
	if x != nil {
		return x.TrackTimeoutBudgets
	}
	return false
}

type isCluster_ClusterDiscoveryType interface {
	isCluster_ClusterDiscoveryType()
}

type Cluster_Type struct {
	// The :ref:`service discovery type <arch_overview_service_discovery_types>`
	// to use for resolving the cluster.
	Type Cluster_DiscoveryType `protobuf:"varint,2,opt,name=type,proto3,enum=envoy.api.v2.Cluster_DiscoveryType,oneof"`
}

type Cluster_ClusterType struct {
	// The custom cluster type.
	ClusterType *Cluster_CustomClusterType `protobuf:"bytes,38,opt,name=cluster_type,json=clusterType,proto3,oneof"`
}

func (*Cluster_Type) isCluster_ClusterDiscoveryType() {}

func (*Cluster_ClusterType) isCluster_ClusterDiscoveryType() {}

type isCluster_LbConfig interface {
	isCluster_LbConfig()
}

type Cluster_RingHashLbConfig_ struct {
	// Optional configuration for the Ring Hash load balancing policy.
	RingHashLbConfig *Cluster_RingHashLbConfig `protobuf:"bytes,23,opt,name=ring_hash_lb_config,json=ringHashLbConfig,proto3,oneof"`
}

type Cluster_OriginalDstLbConfig_ struct {
	// Optional configuration for the Original Destination load balancing policy.
	OriginalDstLbConfig *Cluster_OriginalDstLbConfig `protobuf:"bytes,34,opt,name=original_dst_lb_config,json=originalDstLbConfig,proto3,oneof"`
}

type Cluster_LeastRequestLbConfig_ struct {
	// Optional configuration for the LeastRequest load balancing policy.
	LeastRequestLbConfig *Cluster_LeastRequestLbConfig `protobuf:"bytes,37,opt,name=least_request_lb_config,json=leastRequestLbConfig,proto3,oneof"`
}

func (*Cluster_RingHashLbConfig_) isCluster_LbConfig() {}

func (*Cluster_OriginalDstLbConfig_) isCluster_LbConfig() {}

func (*Cluster_LeastRequestLbConfig_) isCluster_LbConfig() {}

// [#not-implemented-hide:] Extensible load balancing policy configuration.
//
// Every LB policy defined via this mechanism will be identified via a unique name using reverse
// DNS notation. If the policy needs configuration parameters, it must define a message for its
// own configuration, which will be stored in the config field. The name of the policy will tell
// clients which type of message they should expect to see in the config field.
//
// Note that there are cases where it is useful to be able to independently select LB policies
// for choosing a locality and for choosing an endpoint within that locality. For example, a
// given deployment may always use the same policy to choose the locality, but for choosing the
// endpoint within the locality, some clusters may use weighted-round-robin, while others may
// use some sort of session-based balancing.
//
// This can be accomplished via hierarchical LB policies, where the parent LB policy creates a
// child LB policy for each locality. For each request, the parent chooses the locality and then
// delegates to the child policy for that locality to choose the endpoint within the locality.
//
// To facilitate this, the config message for the top-level LB policy may include a field of
// type LoadBalancingPolicy that specifies the child policy.
type LoadBalancingPolicy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Each client will iterate over the list in order and stop at the first policy that it
	// supports. This provides a mechanism for starting to use new LB policies that are not yet
	// supported by all clients.
	Policies      []*LoadBalancingPolicy_Policy `protobuf:"bytes,1,rep,name=policies,proto3" json:"policies,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LoadBalancingPolicy) Reset() {
	*x = LoadBalancingPolicy{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *LoadBalancingPolicy) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*LoadBalancingPolicy) ProtoMessage() {}

func (x *LoadBalancingPolicy) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use LoadBalancingPolicy.ProtoReflect.Descriptor instead.
func (*LoadBalancingPolicy) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{1}
}

func (x *LoadBalancingPolicy) GetPolicies() []*LoadBalancingPolicy_Policy {
	if x != nil {
		return x.Policies
	}
	return nil
}

// An extensible structure containing the address Envoy should bind to when
// establishing upstream connections.
type UpstreamBindConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The address Envoy should bind to when establishing upstream connections.
	SourceAddress *core.Address `protobuf:"bytes,1,opt,name=source_address,json=sourceAddress,proto3" json:"source_address,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpstreamBindConfig) Reset() {
	*x = UpstreamBindConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpstreamBindConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpstreamBindConfig) ProtoMessage() {}

func (x *UpstreamBindConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpstreamBindConfig.ProtoReflect.Descriptor instead.
func (*UpstreamBindConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{2}
}

func (x *UpstreamBindConfig) GetSourceAddress() *core.Address {
	if x != nil {
		return x.SourceAddress
	}
	return nil
}

type UpstreamConnectionOptions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If set then set SO_KEEPALIVE on the socket to enable TCP Keepalives.
	TcpKeepalive  *core.TcpKeepalive `protobuf:"bytes,1,opt,name=tcp_keepalive,json=tcpKeepalive,proto3" json:"tcp_keepalive,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *UpstreamConnectionOptions) Reset() {
	*x = UpstreamConnectionOptions{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *UpstreamConnectionOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*UpstreamConnectionOptions) ProtoMessage() {}

func (x *UpstreamConnectionOptions) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use UpstreamConnectionOptions.ProtoReflect.Descriptor instead.
func (*UpstreamConnectionOptions) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{3}
}

func (x *UpstreamConnectionOptions) GetTcpKeepalive() *core.TcpKeepalive {
	if x != nil {
		return x.TcpKeepalive
	}
	return nil
}

// TransportSocketMatch specifies what transport socket config will be used
// when the match conditions are satisfied.
type Cluster_TransportSocketMatch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The name of the match, used in stats generation.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Optional endpoint metadata match criteria.
	// The connection to the endpoint with metadata matching what is set in this field
	// will use the transport socket configuration specified here.
	// The endpoint's metadata entry in *envoy.transport_socket_match* is used to match
	// against the values specified in this field.
	Match *structpb.Struct `protobuf:"bytes,2,opt,name=match,proto3" json:"match,omitempty"`
	// The configuration of the transport socket.
	TransportSocket *core.TransportSocket `protobuf:"bytes,3,opt,name=transport_socket,json=transportSocket,proto3" json:"transport_socket,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *Cluster_TransportSocketMatch) Reset() {
	*x = Cluster_TransportSocketMatch{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_TransportSocketMatch) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_TransportSocketMatch) ProtoMessage() {}

func (x *Cluster_TransportSocketMatch) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_TransportSocketMatch.ProtoReflect.Descriptor instead.
func (*Cluster_TransportSocketMatch) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 0}
}

func (x *Cluster_TransportSocketMatch) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Cluster_TransportSocketMatch) GetMatch() *structpb.Struct {
	if x != nil {
		return x.Match
	}
	return nil
}

func (x *Cluster_TransportSocketMatch) GetTransportSocket() *core.TransportSocket {
	if x != nil {
		return x.TransportSocket
	}
	return nil
}

// Extended cluster type.
type Cluster_CustomClusterType struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of the cluster to instantiate. The name must match a supported cluster type.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Cluster specific configuration which depends on the cluster being instantiated.
	// See the supported cluster for further documentation.
	TypedConfig   *anypb.Any `protobuf:"bytes,2,opt,name=typed_config,json=typedConfig,proto3" json:"typed_config,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_CustomClusterType) Reset() {
	*x = Cluster_CustomClusterType{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_CustomClusterType) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_CustomClusterType) ProtoMessage() {}

func (x *Cluster_CustomClusterType) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_CustomClusterType.ProtoReflect.Descriptor instead.
func (*Cluster_CustomClusterType) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 1}
}

func (x *Cluster_CustomClusterType) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *Cluster_CustomClusterType) GetTypedConfig() *anypb.Any {
	if x != nil {
		return x.TypedConfig
	}
	return nil
}

// Only valid when discovery type is EDS.
type Cluster_EdsClusterConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configuration for the source of EDS updates for this Cluster.
	EdsConfig *core.ConfigSource `protobuf:"bytes,1,opt,name=eds_config,json=edsConfig,proto3" json:"eds_config,omitempty"`
	// Optional alternative to cluster name to present to EDS. This does not
	// have the same restrictions as cluster name, i.e. it may be arbitrary
	// length.
	ServiceName   string `protobuf:"bytes,2,opt,name=service_name,json=serviceName,proto3" json:"service_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_EdsClusterConfig) Reset() {
	*x = Cluster_EdsClusterConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_EdsClusterConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_EdsClusterConfig) ProtoMessage() {}

func (x *Cluster_EdsClusterConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_EdsClusterConfig.ProtoReflect.Descriptor instead.
func (*Cluster_EdsClusterConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 2}
}

func (x *Cluster_EdsClusterConfig) GetEdsConfig() *core.ConfigSource {
	if x != nil {
		return x.EdsConfig
	}
	return nil
}

func (x *Cluster_EdsClusterConfig) GetServiceName() string {
	if x != nil {
		return x.ServiceName
	}
	return ""
}

// Optionally divide the endpoints in this cluster into subsets defined by
// endpoint metadata and selected by route and weighted cluster metadata.
// [#next-free-field: 8]
type Cluster_LbSubsetConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The behavior used when no endpoint subset matches the selected route's
	// metadata. The value defaults to
	// :ref:`NO_FALLBACK<envoy_api_enum_value_Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
	FallbackPolicy Cluster_LbSubsetConfig_LbSubsetFallbackPolicy `protobuf:"varint,1,opt,name=fallback_policy,json=fallbackPolicy,proto3,enum=envoy.api.v2.Cluster_LbSubsetConfig_LbSubsetFallbackPolicy" json:"fallback_policy,omitempty"`
	// Specifies the default subset of endpoints used during fallback if
	// fallback_policy is
	// :ref:`DEFAULT_SUBSET<envoy_api_enum_value_Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.DEFAULT_SUBSET>`.
	// Each field in default_subset is
	// compared to the matching LbEndpoint.Metadata under the *envoy.lb*
	// namespace. It is valid for no hosts to match, in which case the behavior
	// is the same as a fallback_policy of
	// :ref:`NO_FALLBACK<envoy_api_enum_value_Cluster.LbSubsetConfig.LbSubsetFallbackPolicy.NO_FALLBACK>`.
	DefaultSubset *structpb.Struct `protobuf:"bytes,2,opt,name=default_subset,json=defaultSubset,proto3" json:"default_subset,omitempty"`
	// For each entry, LbEndpoint.Metadata's
	// *envoy.lb* namespace is traversed and a subset is created for each unique
	// combination of key and value. For example:
	//
	// .. code-block:: json
	//
	//	{ "subset_selectors": [
	//	    { "keys": [ "version" ] },
	//	    { "keys": [ "stage", "hardware_type" ] }
	//	]}
	//
	// A subset is matched when the metadata from the selected route and
	// weighted cluster contains the same keys and values as the subset's
	// metadata. The same host may appear in multiple subsets.
	SubsetSelectors []*Cluster_LbSubsetConfig_LbSubsetSelector `protobuf:"bytes,3,rep,name=subset_selectors,json=subsetSelectors,proto3" json:"subset_selectors,omitempty"`
	// If true, routing to subsets will take into account the localities and locality weights of the
	// endpoints when making the routing decision.
	//
	// There are some potential pitfalls associated with enabling this feature, as the resulting
	// traffic split after applying both a subset match and locality weights might be undesirable.
	//
	// Consider for example a situation in which you have 50/50 split across two localities X/Y
	// which have 100 hosts each without subsetting. If the subset LB results in X having only 1
	// host selected but Y having 100, then a lot more load is being dumped on the single host in X
	// than originally anticipated in the load balancing assignment delivered via EDS.
	LocalityWeightAware bool `protobuf:"varint,4,opt,name=locality_weight_aware,json=localityWeightAware,proto3" json:"locality_weight_aware,omitempty"`
	// When used with locality_weight_aware, scales the weight of each locality by the ratio
	// of hosts in the subset vs hosts in the original subset. This aims to even out the load
	// going to an individual locality if said locality is disproportionately affected by the
	// subset predicate.
	ScaleLocalityWeight bool `protobuf:"varint,5,opt,name=scale_locality_weight,json=scaleLocalityWeight,proto3" json:"scale_locality_weight,omitempty"`
	// If true, when a fallback policy is configured and its corresponding subset fails to find
	// a host this will cause any host to be selected instead.
	//
	// This is useful when using the default subset as the fallback policy, given the default
	// subset might become empty. With this option enabled, if that happens the LB will attempt
	// to select a host from the entire cluster.
	PanicModeAny bool `protobuf:"varint,6,opt,name=panic_mode_any,json=panicModeAny,proto3" json:"panic_mode_any,omitempty"`
	// If true, metadata specified for a metadata key will be matched against the corresponding
	// endpoint metadata if the endpoint metadata matches the value exactly OR it is a list value
	// and any of the elements in the list matches the criteria.
	ListAsAny     bool `protobuf:"varint,7,opt,name=list_as_any,json=listAsAny,proto3" json:"list_as_any,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_LbSubsetConfig) Reset() {
	*x = Cluster_LbSubsetConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_LbSubsetConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_LbSubsetConfig) ProtoMessage() {}

func (x *Cluster_LbSubsetConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_LbSubsetConfig.ProtoReflect.Descriptor instead.
func (*Cluster_LbSubsetConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 3}
}

func (x *Cluster_LbSubsetConfig) GetFallbackPolicy() Cluster_LbSubsetConfig_LbSubsetFallbackPolicy {
	if x != nil {
		return x.FallbackPolicy
	}
	return Cluster_LbSubsetConfig_NO_FALLBACK
}

func (x *Cluster_LbSubsetConfig) GetDefaultSubset() *structpb.Struct {
	if x != nil {
		return x.DefaultSubset
	}
	return nil
}

func (x *Cluster_LbSubsetConfig) GetSubsetSelectors() []*Cluster_LbSubsetConfig_LbSubsetSelector {
	if x != nil {
		return x.SubsetSelectors
	}
	return nil
}

func (x *Cluster_LbSubsetConfig) GetLocalityWeightAware() bool {
	if x != nil {
		return x.LocalityWeightAware
	}
	return false
}

func (x *Cluster_LbSubsetConfig) GetScaleLocalityWeight() bool {
	if x != nil {
		return x.ScaleLocalityWeight
	}
	return false
}

func (x *Cluster_LbSubsetConfig) GetPanicModeAny() bool {
	if x != nil {
		return x.PanicModeAny
	}
	return false
}

func (x *Cluster_LbSubsetConfig) GetListAsAny() bool {
	if x != nil {
		return x.ListAsAny
	}
	return false
}

// Specific configuration for the LeastRequest load balancing policy.
type Cluster_LeastRequestLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The number of random healthy hosts from which the host with the fewest active requests will
	// be chosen. Defaults to 2 so that we perform two-choice selection if the field is not set.
	ChoiceCount   *wrapperspb.UInt32Value `protobuf:"bytes,1,opt,name=choice_count,json=choiceCount,proto3" json:"choice_count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_LeastRequestLbConfig) Reset() {
	*x = Cluster_LeastRequestLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_LeastRequestLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_LeastRequestLbConfig) ProtoMessage() {}

func (x *Cluster_LeastRequestLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_LeastRequestLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_LeastRequestLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 4}
}

func (x *Cluster_LeastRequestLbConfig) GetChoiceCount() *wrapperspb.UInt32Value {
	if x != nil {
		return x.ChoiceCount
	}
	return nil
}

// Specific configuration for the :ref:`RingHash<arch_overview_load_balancing_types_ring_hash>`
// load balancing policy.
type Cluster_RingHashLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Minimum hash ring size. The larger the ring is (that is, the more hashes there are for each
	// provided host) the better the request distribution will reflect the desired weights. Defaults
	// to 1024 entries, and limited to 8M entries. See also
	// :ref:`maximum_ring_size<envoy_api_field_Cluster.RingHashLbConfig.maximum_ring_size>`.
	MinimumRingSize *wrapperspb.UInt64Value `protobuf:"bytes,1,opt,name=minimum_ring_size,json=minimumRingSize,proto3" json:"minimum_ring_size,omitempty"`
	// The hash function used to hash hosts onto the ketama ring. The value defaults to
	// :ref:`XX_HASH<envoy_api_enum_value_Cluster.RingHashLbConfig.HashFunction.XX_HASH>`.
	HashFunction Cluster_RingHashLbConfig_HashFunction `protobuf:"varint,3,opt,name=hash_function,json=hashFunction,proto3,enum=envoy.api.v2.Cluster_RingHashLbConfig_HashFunction" json:"hash_function,omitempty"`
	// Maximum hash ring size. Defaults to 8M entries, and limited to 8M entries, but can be lowered
	// to further constrain resource use. See also
	// :ref:`minimum_ring_size<envoy_api_field_Cluster.RingHashLbConfig.minimum_ring_size>`.
	MaximumRingSize *wrapperspb.UInt64Value `protobuf:"bytes,4,opt,name=maximum_ring_size,json=maximumRingSize,proto3" json:"maximum_ring_size,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *Cluster_RingHashLbConfig) Reset() {
	*x = Cluster_RingHashLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_RingHashLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_RingHashLbConfig) ProtoMessage() {}

func (x *Cluster_RingHashLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_RingHashLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_RingHashLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 5}
}

func (x *Cluster_RingHashLbConfig) GetMinimumRingSize() *wrapperspb.UInt64Value {
	if x != nil {
		return x.MinimumRingSize
	}
	return nil
}

func (x *Cluster_RingHashLbConfig) GetHashFunction() Cluster_RingHashLbConfig_HashFunction {
	if x != nil {
		return x.HashFunction
	}
	return Cluster_RingHashLbConfig_XX_HASH
}

func (x *Cluster_RingHashLbConfig) GetMaximumRingSize() *wrapperspb.UInt64Value {
	if x != nil {
		return x.MaximumRingSize
	}
	return nil
}

// Specific configuration for the
// :ref:`Original Destination <arch_overview_load_balancing_types_original_destination>`
// load balancing policy.
type Cluster_OriginalDstLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// When true, :ref:`x-envoy-original-dst-host
	// <config_http_conn_man_headers_x-envoy-original-dst-host>` can be used to override destination
	// address.
	//
	// .. attention::
	//
	//	This header isn't sanitized by default, so enabling this feature allows HTTP clients to
	//	route traffic to arbitrary hosts and/or ports, which may have serious security
	//	consequences.
	//
	// .. note::
	//
	//	If the header appears multiple times only the first value is used.
	UseHttpHeader bool `protobuf:"varint,1,opt,name=use_http_header,json=useHttpHeader,proto3" json:"use_http_header,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_OriginalDstLbConfig) Reset() {
	*x = Cluster_OriginalDstLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_OriginalDstLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_OriginalDstLbConfig) ProtoMessage() {}

func (x *Cluster_OriginalDstLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_OriginalDstLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_OriginalDstLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 6}
}

func (x *Cluster_OriginalDstLbConfig) GetUseHttpHeader() bool {
	if x != nil {
		return x.UseHttpHeader
	}
	return false
}

// Common configuration for all load balancer implementations.
// [#next-free-field: 8]
type Cluster_CommonLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configures the :ref:`healthy panic threshold <arch_overview_load_balancing_panic_threshold>`.
	// If not specified, the default is 50%.
	// To disable panic mode, set to 0%.
	//
	// .. note::
	//
	//	The specified percent will be truncated to the nearest 1%.
	HealthyPanicThreshold *_type.Percent `protobuf:"bytes,1,opt,name=healthy_panic_threshold,json=healthyPanicThreshold,proto3" json:"healthy_panic_threshold,omitempty"`
	// Types that are valid to be assigned to LocalityConfigSpecifier:
	//
	//	*Cluster_CommonLbConfig_ZoneAwareLbConfig_
	//	*Cluster_CommonLbConfig_LocalityWeightedLbConfig_
	LocalityConfigSpecifier isCluster_CommonLbConfig_LocalityConfigSpecifier `protobuf_oneof:"locality_config_specifier"`
	// If set, all health check/weight/metadata updates that happen within this duration will be
	// merged and delivered in one shot when the duration expires. The start of the duration is when
	// the first update happens. This is useful for big clusters, with potentially noisy deploys
	// that might trigger excessive CPU usage due to a constant stream of healthcheck state changes
	// or metadata updates. The first set of updates to be seen apply immediately (e.g.: a new
	// cluster). Please always keep in mind that the use of sandbox technologies may change this
	// behavior.
	//
	// If this is not set, we default to a merge window of 1000ms. To disable it, set the merge
	// window to 0.
	//
	// Note: merging does not apply to cluster membership changes (e.g.: adds/removes); this is
	// because merging those updates isn't currently safe. See
	// https://github.com/envoyproxy/envoy/pull/3941.
	UpdateMergeWindow *durationpb.Duration `protobuf:"bytes,4,opt,name=update_merge_window,json=updateMergeWindow,proto3" json:"update_merge_window,omitempty"`
	// If set to true, Envoy will not consider new hosts when computing load balancing weights until
	// they have been health checked for the first time. This will have no effect unless
	// active health checking is also configured.
	//
	// Ignoring a host means that for any load balancing calculations that adjust weights based
	// on the ratio of eligible hosts and total hosts (priority spillover, locality weighting and
	// panic mode) Envoy will exclude these hosts in the denominator.
	//
	// For example, with hosts in two priorities P0 and P1, where P0 looks like
	// {healthy, unhealthy (new), unhealthy (new)}
	// and where P1 looks like
	// {healthy, healthy}
	// all traffic will still hit P0, as 1 / (3 - 2) = 1.
	//
	// Enabling this will allow scaling up the number of hosts for a given cluster without entering
	// panic mode or triggering priority spillover, assuming the hosts pass the first health check.
	//
	// If panic mode is triggered, new hosts are still eligible for traffic; they simply do not
	// contribute to the calculation when deciding whether panic mode is enabled or not.
	IgnoreNewHostsUntilFirstHc bool `protobuf:"varint,5,opt,name=ignore_new_hosts_until_first_hc,json=ignoreNewHostsUntilFirstHc,proto3" json:"ignore_new_hosts_until_first_hc,omitempty"`
	// If set to `true`, the cluster manager will drain all existing
	// connections to upstream hosts whenever hosts are added or removed from the cluster.
	CloseConnectionsOnHostSetChange bool `protobuf:"varint,6,opt,name=close_connections_on_host_set_change,json=closeConnectionsOnHostSetChange,proto3" json:"close_connections_on_host_set_change,omitempty"`
	// Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
	ConsistentHashingLbConfig *Cluster_CommonLbConfig_ConsistentHashingLbConfig `protobuf:"bytes,7,opt,name=consistent_hashing_lb_config,json=consistentHashingLbConfig,proto3" json:"consistent_hashing_lb_config,omitempty"`
	unknownFields             protoimpl.UnknownFields
	sizeCache                 protoimpl.SizeCache
}

func (x *Cluster_CommonLbConfig) Reset() {
	*x = Cluster_CommonLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_CommonLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_CommonLbConfig) ProtoMessage() {}

func (x *Cluster_CommonLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_CommonLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_CommonLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 7}
}

func (x *Cluster_CommonLbConfig) GetHealthyPanicThreshold() *_type.Percent {
	if x != nil {
		return x.HealthyPanicThreshold
	}
	return nil
}

func (x *Cluster_CommonLbConfig) GetLocalityConfigSpecifier() isCluster_CommonLbConfig_LocalityConfigSpecifier {
	if x != nil {
		return x.LocalityConfigSpecifier
	}
	return nil
}

func (x *Cluster_CommonLbConfig) GetZoneAwareLbConfig() *Cluster_CommonLbConfig_ZoneAwareLbConfig {
	if x != nil {
		if x, ok := x.LocalityConfigSpecifier.(*Cluster_CommonLbConfig_ZoneAwareLbConfig_); ok {
			return x.ZoneAwareLbConfig
		}
	}
	return nil
}

func (x *Cluster_CommonLbConfig) GetLocalityWeightedLbConfig() *Cluster_CommonLbConfig_LocalityWeightedLbConfig {
	if x != nil {
		if x, ok := x.LocalityConfigSpecifier.(*Cluster_CommonLbConfig_LocalityWeightedLbConfig_); ok {
			return x.LocalityWeightedLbConfig
		}
	}
	return nil
}

func (x *Cluster_CommonLbConfig) GetUpdateMergeWindow() *durationpb.Duration {
	if x != nil {
		return x.UpdateMergeWindow
	}
	return nil
}

func (x *Cluster_CommonLbConfig) GetIgnoreNewHostsUntilFirstHc() bool {
	if x != nil {
		return x.IgnoreNewHostsUntilFirstHc
	}
	return false
}

func (x *Cluster_CommonLbConfig) GetCloseConnectionsOnHostSetChange() bool {
	if x != nil {
		return x.CloseConnectionsOnHostSetChange
	}
	return false
}

func (x *Cluster_CommonLbConfig) GetConsistentHashingLbConfig() *Cluster_CommonLbConfig_ConsistentHashingLbConfig {
	if x != nil {
		return x.ConsistentHashingLbConfig
	}
	return nil
}

type isCluster_CommonLbConfig_LocalityConfigSpecifier interface {
	isCluster_CommonLbConfig_LocalityConfigSpecifier()
}

type Cluster_CommonLbConfig_ZoneAwareLbConfig_ struct {
	ZoneAwareLbConfig *Cluster_CommonLbConfig_ZoneAwareLbConfig `protobuf:"bytes,2,opt,name=zone_aware_lb_config,json=zoneAwareLbConfig,proto3,oneof"`
}

type Cluster_CommonLbConfig_LocalityWeightedLbConfig_ struct {
	LocalityWeightedLbConfig *Cluster_CommonLbConfig_LocalityWeightedLbConfig `protobuf:"bytes,3,opt,name=locality_weighted_lb_config,json=localityWeightedLbConfig,proto3,oneof"`
}

func (*Cluster_CommonLbConfig_ZoneAwareLbConfig_) isCluster_CommonLbConfig_LocalityConfigSpecifier() {
}

func (*Cluster_CommonLbConfig_LocalityWeightedLbConfig_) isCluster_CommonLbConfig_LocalityConfigSpecifier() {
}

type Cluster_RefreshRate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Specifies the base interval between refreshes. This parameter is required and must be greater
	// than zero and less than
	// :ref:`max_interval <envoy_api_field_Cluster.RefreshRate.max_interval>`.
	BaseInterval *durationpb.Duration `protobuf:"bytes,1,opt,name=base_interval,json=baseInterval,proto3" json:"base_interval,omitempty"`
	// Specifies the maximum interval between refreshes. This parameter is optional, but must be
	// greater than or equal to the
	// :ref:`base_interval <envoy_api_field_Cluster.RefreshRate.base_interval>`  if set. The default
	// is 10 times the :ref:`base_interval <envoy_api_field_Cluster.RefreshRate.base_interval>`.
	MaxInterval   *durationpb.Duration `protobuf:"bytes,2,opt,name=max_interval,json=maxInterval,proto3" json:"max_interval,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_RefreshRate) Reset() {
	*x = Cluster_RefreshRate{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_RefreshRate) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_RefreshRate) ProtoMessage() {}

func (x *Cluster_RefreshRate) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_RefreshRate.ProtoReflect.Descriptor instead.
func (*Cluster_RefreshRate) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 8}
}

func (x *Cluster_RefreshRate) GetBaseInterval() *durationpb.Duration {
	if x != nil {
		return x.BaseInterval
	}
	return nil
}

func (x *Cluster_RefreshRate) GetMaxInterval() *durationpb.Duration {
	if x != nil {
		return x.MaxInterval
	}
	return nil
}

// Specifications for subsets.
type Cluster_LbSubsetConfig_LbSubsetSelector struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// List of keys to match with the weighted cluster metadata.
	Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
	// The behavior used when no endpoint subset matches the selected route's
	// metadata.
	FallbackPolicy Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy `protobuf:"varint,2,opt,name=fallback_policy,json=fallbackPolicy,proto3,enum=envoy.api.v2.Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy" json:"fallback_policy,omitempty"`
	// Subset of
	// :ref:`keys<envoy_api_field_Cluster.LbSubsetConfig.LbSubsetSelector.keys>` used by
	// :ref:`KEYS_SUBSET<envoy_api_enum_value_Cluster.LbSubsetConfig.LbSubsetSelector.LbSubsetSelectorFallbackPolicy.KEYS_SUBSET>`
	// fallback policy.
	// It has to be a non empty list if KEYS_SUBSET fallback policy is selected.
	// For any other fallback policy the parameter is not used and should not be set.
	// Only values also present in
	// :ref:`keys<envoy_api_field_Cluster.LbSubsetConfig.LbSubsetSelector.keys>` are allowed, but
	// `fallback_keys_subset` cannot be equal to `keys`.
	FallbackKeysSubset []string `protobuf:"bytes,3,rep,name=fallback_keys_subset,json=fallbackKeysSubset,proto3" json:"fallback_keys_subset,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *Cluster_LbSubsetConfig_LbSubsetSelector) Reset() {
	*x = Cluster_LbSubsetConfig_LbSubsetSelector{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_LbSubsetConfig_LbSubsetSelector) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_LbSubsetConfig_LbSubsetSelector) ProtoMessage() {}

func (x *Cluster_LbSubsetConfig_LbSubsetSelector) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[15]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_LbSubsetConfig_LbSubsetSelector.ProtoReflect.Descriptor instead.
func (*Cluster_LbSubsetConfig_LbSubsetSelector) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 3, 0}
}

func (x *Cluster_LbSubsetConfig_LbSubsetSelector) GetKeys() []string {
	if x != nil {
		return x.Keys
	}
	return nil
}

func (x *Cluster_LbSubsetConfig_LbSubsetSelector) GetFallbackPolicy() Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy {
	if x != nil {
		return x.FallbackPolicy
	}
	return Cluster_LbSubsetConfig_LbSubsetSelector_NOT_DEFINED
}

func (x *Cluster_LbSubsetConfig_LbSubsetSelector) GetFallbackKeysSubset() []string {
	if x != nil {
		return x.FallbackKeysSubset
	}
	return nil
}

// Configuration for :ref:`zone aware routing
// <arch_overview_load_balancing_zone_aware_routing>`.
type Cluster_CommonLbConfig_ZoneAwareLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configures percentage of requests that will be considered for zone aware routing
	// if zone aware routing is configured. If not specified, the default is 100%.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	RoutingEnabled *_type.Percent `protobuf:"bytes,1,opt,name=routing_enabled,json=routingEnabled,proto3" json:"routing_enabled,omitempty"`
	// Configures minimum upstream cluster size required for zone aware routing
	// If upstream cluster size is less than specified, zone aware routing is not performed
	// even if zone aware routing is configured. If not specified, the default is 6.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	MinClusterSize *wrapperspb.UInt64Value `protobuf:"bytes,2,opt,name=min_cluster_size,json=minClusterSize,proto3" json:"min_cluster_size,omitempty"`
	// If set to true, Envoy will not consider any hosts when the cluster is in :ref:`panic
	// mode<arch_overview_load_balancing_panic_threshold>`. Instead, the cluster will fail all
	// requests as if all hosts are unhealthy. This can help avoid potentially overwhelming a
	// failing service.
	FailTrafficOnPanic bool `protobuf:"varint,3,opt,name=fail_traffic_on_panic,json=failTrafficOnPanic,proto3" json:"fail_traffic_on_panic,omitempty"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

func (x *Cluster_CommonLbConfig_ZoneAwareLbConfig) Reset() {
	*x = Cluster_CommonLbConfig_ZoneAwareLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_CommonLbConfig_ZoneAwareLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_CommonLbConfig_ZoneAwareLbConfig) ProtoMessage() {}

func (x *Cluster_CommonLbConfig_ZoneAwareLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_CommonLbConfig_ZoneAwareLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_CommonLbConfig_ZoneAwareLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 7, 0}
}

func (x *Cluster_CommonLbConfig_ZoneAwareLbConfig) GetRoutingEnabled() *_type.Percent {
	if x != nil {
		return x.RoutingEnabled
	}
	return nil
}

func (x *Cluster_CommonLbConfig_ZoneAwareLbConfig) GetMinClusterSize() *wrapperspb.UInt64Value {
	if x != nil {
		return x.MinClusterSize
	}
	return nil
}

func (x *Cluster_CommonLbConfig_ZoneAwareLbConfig) GetFailTrafficOnPanic() bool {
	if x != nil {
		return x.FailTrafficOnPanic
	}
	return false
}

// Configuration for :ref:`locality weighted load balancing
// <arch_overview_load_balancing_locality_weighted_lb>`
type Cluster_CommonLbConfig_LocalityWeightedLbConfig struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Cluster_CommonLbConfig_LocalityWeightedLbConfig) Reset() {
	*x = Cluster_CommonLbConfig_LocalityWeightedLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_CommonLbConfig_LocalityWeightedLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_CommonLbConfig_LocalityWeightedLbConfig) ProtoMessage() {}

func (x *Cluster_CommonLbConfig_LocalityWeightedLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_CommonLbConfig_LocalityWeightedLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_CommonLbConfig_LocalityWeightedLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 7, 1}
}

// Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
type Cluster_CommonLbConfig_ConsistentHashingLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If set to `true`, the cluster will use hostname instead of the resolved
	// address as the key to consistently hash to an upstream host. Only valid for StrictDNS clusters with hostnames which resolve to a single IP address.
	UseHostnameForHashing bool `protobuf:"varint,1,opt,name=use_hostname_for_hashing,json=useHostnameForHashing,proto3" json:"use_hostname_for_hashing,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *Cluster_CommonLbConfig_ConsistentHashingLbConfig) Reset() {
	*x = Cluster_CommonLbConfig_ConsistentHashingLbConfig{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Cluster_CommonLbConfig_ConsistentHashingLbConfig) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Cluster_CommonLbConfig_ConsistentHashingLbConfig) ProtoMessage() {}

func (x *Cluster_CommonLbConfig_ConsistentHashingLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Cluster_CommonLbConfig_ConsistentHashingLbConfig.ProtoReflect.Descriptor instead.
func (*Cluster_CommonLbConfig_ConsistentHashingLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{0, 7, 2}
}

func (x *Cluster_CommonLbConfig_ConsistentHashingLbConfig) GetUseHostnameForHashing() bool {
	if x != nil {
		return x.UseHostnameForHashing
	}
	return false
}

type LoadBalancingPolicy_Policy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The name of the LB policy.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Optional config for the LB policy.
	// No more than one of these two fields may be populated.
	//
	// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
	Config        *structpb.Struct `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
	TypedConfig   *anypb.Any       `protobuf:"bytes,3,opt,name=typed_config,json=typedConfig,proto3" json:"typed_config,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *LoadBalancingPolicy_Policy) Reset() {
	*x = LoadBalancingPolicy_Policy{}
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *LoadBalancingPolicy_Policy) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*LoadBalancingPolicy_Policy) ProtoMessage() {}

func (x *LoadBalancingPolicy_Policy) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_api_v2_cluster_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use LoadBalancingPolicy_Policy.ProtoReflect.Descriptor instead.
func (*LoadBalancingPolicy_Policy) Descriptor() ([]byte, []int) {
	return file_envoy_api_v2_cluster_proto_rawDescGZIP(), []int{1, 0}
}

func (x *LoadBalancingPolicy_Policy) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

// Deprecated: Marked as deprecated in envoy/api/v2/cluster.proto.
func (x *LoadBalancingPolicy_Policy) GetConfig() *structpb.Struct {
	if x != nil {
		return x.Config
	}
	return nil
}

func (x *LoadBalancingPolicy_Policy) GetTypedConfig() *anypb.Any {
	if x != nil {
		return x.TypedConfig
	}
	return nil
}

var File_envoy_api_v2_cluster_proto protoreflect.FileDescriptor

const file_envoy_api_v2_cluster_proto_rawDesc = "" +
	"\n" +
	"\x1aenvoy/api/v2/cluster.proto\x12\fenvoy.api.v2\x1a\x1benvoy/api/v2/auth/tls.proto\x1a*envoy/api/v2/cluster/circuit_breaker.proto\x1a!envoy/api/v2/cluster/filter.proto\x1a,envoy/api/v2/cluster/outlier_detection.proto\x1a\x1fenvoy/api/v2/core/address.proto\x1a\x1cenvoy/api/v2/core/base.proto\x1a%envoy/api/v2/core/config_source.proto\x1a$envoy/api/v2/core/health_check.proto\x1a envoy/api/v2/core/protocol.proto\x1a\x1benvoy/api/v2/endpoint.proto\x1a\x18envoy/type/percent.proto\x1a\x19google/protobuf/any.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1cgoogle/protobuf/struct.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a#envoy/annotations/deprecation.proto\x1a\x1eudpa/annotations/migrate.proto\x1a\x1dudpa/annotations/status.proto\x1a\x17validate/validate.proto\"\xd89\n" +
	"\aCluster\x12d\n" +
	"\x18transport_socket_matches\x18+ \x03(\v2*.envoy.api.v2.Cluster.TransportSocketMatchR\x16transportSocketMatches\x12\x1b\n" +
	"\x04name\x18\x01 \x01(\tB\a\xfaB\x04r\x02 \x01R\x04name\x12\"\n" +
	"\ralt_stat_name\x18\x1c \x01(\tR\valtStatName\x12C\n" +
	"\x04type\x18\x02 \x01(\x0e2#.envoy.api.v2.Cluster.DiscoveryTypeB\b\xfaB\x05\x82\x01\x02\x10\x01H\x00R\x04type\x12L\n" +
	"\fcluster_type\x18& \x01(\v2'.envoy.api.v2.Cluster.CustomClusterTypeH\x00R\vclusterType\x12T\n" +
	"\x12eds_cluster_config\x18\x03 \x01(\v2&.envoy.api.v2.Cluster.EdsClusterConfigR\x10edsClusterConfig\x12L\n" +
	"\x0fconnect_timeout\x18\x04 \x01(\v2\x19.google.protobuf.DurationB\b\xfaB\x05\xaa\x01\x02*\x00R\x0econnectTimeout\x12f\n" +
	"!per_connection_buffer_limit_bytes\x18\x05 \x01(\v2\x1c.google.protobuf.UInt32ValueR\x1dperConnectionBufferLimitBytes\x12E\n" +
	"\tlb_policy\x18\x06 \x01(\x0e2\x1e.envoy.api.v2.Cluster.LbPolicyB\b\xfaB\x05\x82\x01\x02\x10\x01R\blbPolicy\x124\n" +
	"\x05hosts\x18\a \x03(\v2\x1a.envoy.api.v2.core.AddressB\x02\x18\x01R\x05hosts\x12L\n" +
	"\x0fload_assignment\x18! \x01(\v2#.envoy.api.v2.ClusterLoadAssignmentR\x0eloadAssignment\x12C\n" +
	"\rhealth_checks\x18\b \x03(\v2\x1e.envoy.api.v2.core.HealthCheckR\fhealthChecks\x12[\n" +
	"\x1bmax_requests_per_connection\x18\t \x01(\v2\x1c.google.protobuf.UInt32ValueR\x18maxRequestsPerConnection\x12P\n" +
	"\x10circuit_breakers\x18\n" +
	" \x01(\v2%.envoy.api.v2.cluster.CircuitBreakersR\x0fcircuitBreakers\x12P\n" +
	"\vtls_context\x18\v \x01(\v2%.envoy.api.v2.auth.UpstreamTlsContextB\b\xb8\xee\xf2\xd2\x05\x01\x18\x01R\n" +
	"tlsContext\x12s\n" +
	"\x1eupstream_http_protocol_options\x18. \x01(\v2..envoy.api.v2.core.UpstreamHttpProtocolOptionsR\x1bupstreamHttpProtocolOptions\x12g\n" +
	"\x1ccommon_http_protocol_options\x18\x1d \x01(\v2&.envoy.api.v2.core.HttpProtocolOptionsR\x19commonHttpProtocolOptions\x12[\n" +
	"\x15http_protocol_options\x18\r \x01(\v2'.envoy.api.v2.core.Http1ProtocolOptionsR\x13httpProtocolOptions\x12]\n" +
	"\x16http2_protocol_options\x18\x0e \x01(\v2'.envoy.api.v2.core.Http2ProtocolOptionsR\x14http2ProtocolOptions\x12{\n" +
	"\x1aextension_protocol_options\x18# \x03(\v23.envoy.api.v2.Cluster.ExtensionProtocolOptionsEntryB\b\xb8\xee\xf2\xd2\x05\x01\x18\x01R\x18extensionProtocolOptions\x12\x81\x01\n" +
	" typed_extension_protocol_options\x18$ \x03(\v28.envoy.api.v2.Cluster.TypedExtensionProtocolOptionsEntryR\x1dtypedExtensionProtocolOptions\x12Q\n" +
	"\x10dns_refresh_rate\x18\x10 \x01(\v2\x19.google.protobuf.DurationB\f\xfaB\t\xaa\x01\x06*\x04\x10\xc0\x84=R\x0ednsRefreshRate\x12Z\n" +
	"\x18dns_failure_refresh_rate\x18, \x01(\v2!.envoy.api.v2.Cluster.RefreshRateR\x15dnsFailureRefreshRate\x12&\n" +
	"\x0frespect_dns_ttl\x18' \x01(\bR\rrespectDnsTtl\x12[\n" +
	"\x11dns_lookup_family\x18\x11 \x01(\x0e2%.envoy.api.v2.Cluster.DnsLookupFamilyB\b\xfaB\x05\x82\x01\x02\x10\x01R\x0fdnsLookupFamily\x12?\n" +
	"\rdns_resolvers\x18\x12 \x03(\v2\x1a.envoy.api.v2.core.AddressR\fdnsResolvers\x124\n" +
	"\x17use_tcp_for_dns_lookups\x18- \x01(\bR\x13useTcpForDnsLookups\x12S\n" +
	"\x11outlier_detection\x18\x13 \x01(\v2&.envoy.api.v2.cluster.OutlierDetectionR\x10outlierDetection\x12N\n" +
	"\x10cleanup_interval\x18\x14 \x01(\v2\x19.google.protobuf.DurationB\b\xfaB\x05\xaa\x01\x02*\x00R\x0fcleanupInterval\x12O\n" +
	"\x14upstream_bind_config\x18\x15 \x01(\v2\x1d.envoy.api.v2.core.BindConfigR\x12upstreamBindConfig\x12N\n" +
	"\x10lb_subset_config\x18\x16 \x01(\v2$.envoy.api.v2.Cluster.LbSubsetConfigR\x0elbSubsetConfig\x12W\n" +
	"\x13ring_hash_lb_config\x18\x17 \x01(\v2&.envoy.api.v2.Cluster.RingHashLbConfigH\x01R\x10ringHashLbConfig\x12`\n" +
	"\x16original_dst_lb_config\x18\" \x01(\v2).envoy.api.v2.Cluster.OriginalDstLbConfigH\x01R\x13originalDstLbConfig\x12c\n" +
	"\x17least_request_lb_config\x18% \x01(\v2*.envoy.api.v2.Cluster.LeastRequestLbConfigH\x01R\x14leastRequestLbConfig\x12N\n" +
	"\x10common_lb_config\x18\x1b \x01(\v2$.envoy.api.v2.Cluster.CommonLbConfigR\x0ecommonLbConfig\x12M\n" +
	"\x10transport_socket\x18\x18 \x01(\v2\".envoy.api.v2.core.TransportSocketR\x0ftransportSocket\x127\n" +
	"\bmetadata\x18\x19 \x01(\v2\x1b.envoy.api.v2.core.MetadataR\bmetadata\x12]\n" +
	"\x12protocol_selection\x18\x1a \x01(\x0e2..envoy.api.v2.Cluster.ClusterProtocolSelectionR\x11protocolSelection\x12g\n" +
	"\x1bupstream_connection_options\x18\x1e \x01(\v2'.envoy.api.v2.UpstreamConnectionOptionsR\x19upstreamConnectionOptions\x12U\n" +
	"(close_connections_on_host_health_failure\x18\x1f \x01(\bR#closeConnectionsOnHostHealthFailure\x12o\n" +
	"!drain_connections_on_host_removal\x18  \x01(\bB%\xf2\x98\xfe\x8f\x05\x1f\n" +
	"\x1dignore_health_on_host_removalR\x1ddrainConnectionsOnHostRemoval\x126\n" +
	"\afilters\x18( \x03(\v2\x1c.envoy.api.v2.cluster.FilterR\afilters\x12U\n" +
	"\x15load_balancing_policy\x18) \x01(\v2!.envoy.api.v2.LoadBalancingPolicyR\x13loadBalancingPolicy\x12>\n" +
	"\n" +
	"lrs_server\x18* \x01(\v2\x1f.envoy.api.v2.core.ConfigSourceR\tlrsServer\x122\n" +
	"\x15track_timeout_budgets\x18/ \x01(\bR\x13trackTimeoutBudgets\x1a\xb1\x01\n" +
	"\x14TransportSocketMatch\x12\x1b\n" +
	"\x04name\x18\x01 \x01(\tB\a\xfaB\x04r\x02\x10\x01R\x04name\x12-\n" +
	"\x05match\x18\x02 \x01(\v2\x17.google.protobuf.StructR\x05match\x12M\n" +
	"\x10transport_socket\x18\x03 \x01(\v2\".envoy.api.v2.core.TransportSocketR\x0ftransportSocket\x1ai\n" +
	"\x11CustomClusterType\x12\x1b\n" +
	"\x04name\x18\x01 \x01(\tB\a\xfaB\x04r\x02 \x01R\x04name\x127\n" +
	"\ftyped_config\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\vtypedConfig\x1au\n" +
	"\x10EdsClusterConfig\x12>\n" +
	"\n" +
	"eds_config\x18\x01 \x01(\v2\x1f.envoy.api.v2.core.ConfigSourceR\tedsConfig\x12!\n" +
	"\fservice_name\x18\x02 \x01(\tR\vserviceName\x1a\x81\a\n" +
	"\x0eLbSubsetConfig\x12n\n" +
	"\x0ffallback_policy\x18\x01 \x01(\x0e2;.envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetFallbackPolicyB\b\xfaB\x05\x82\x01\x02\x10\x01R\x0efallbackPolicy\x12>\n" +
	"\x0edefault_subset\x18\x02 \x01(\v2\x17.google.protobuf.StructR\rdefaultSubset\x12`\n" +
	"\x10subset_selectors\x18\x03 \x03(\v25.envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelectorR\x0fsubsetSelectors\x122\n" +
	"\x15locality_weight_aware\x18\x04 \x01(\bR\x13localityWeightAware\x122\n" +
	"\x15scale_locality_weight\x18\x05 \x01(\bR\x13scaleLocalityWeight\x12$\n" +
	"\x0epanic_mode_any\x18\x06 \x01(\bR\fpanicModeAny\x12\x1e\n" +
	"\vlist_as_any\x18\a \x01(\bR\tlistAsAny\x1a\xdd\x02\n" +
	"\x10LbSubsetSelector\x12\x12\n" +
	"\x04keys\x18\x01 \x03(\tR\x04keys\x12\x87\x01\n" +
	"\x0ffallback_policy\x18\x02 \x01(\x0e2T.envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector.LbSubsetSelectorFallbackPolicyB\b\xfaB\x05\x82\x01\x02\x10\x01R\x0efallbackPolicy\x120\n" +
	"\x14fallback_keys_subset\x18\x03 \x03(\tR\x12fallbackKeysSubset\"y\n" +
	"\x1eLbSubsetSelectorFallbackPolicy\x12\x0f\n" +
	"\vNOT_DEFINED\x10\x00\x12\x0f\n" +
	"\vNO_FALLBACK\x10\x01\x12\x10\n" +
	"\fANY_ENDPOINT\x10\x02\x12\x12\n" +
	"\x0eDEFAULT_SUBSET\x10\x03\x12\x0f\n" +
	"\vKEYS_SUBSET\x10\x04\"O\n" +
	"\x16LbSubsetFallbackPolicy\x12\x0f\n" +
	"\vNO_FALLBACK\x10\x00\x12\x10\n" +
	"\fANY_ENDPOINT\x10\x01\x12\x12\n" +
	"\x0eDEFAULT_SUBSET\x10\x02\x1a`\n" +
	"\x14LeastRequestLbConfig\x12H\n" +
	"\fchoice_count\x18\x01 \x01(\v2\x1c.google.protobuf.UInt32ValueB\a\xfaB\x04*\x02(\x02R\vchoiceCount\x1a\xd8\x02\n" +
	"\x10RingHashLbConfig\x12T\n" +
	"\x11minimum_ring_size\x18\x01 \x01(\v2\x1c.google.protobuf.UInt64ValueB\n" +
	"\xfaB\a2\x05\x18\x80\x80\x80\x04R\x0fminimumRingSize\x12b\n" +
	"\rhash_function\x18\x03 \x01(\x0e23.envoy.api.v2.Cluster.RingHashLbConfig.HashFunctionB\b\xfaB\x05\x82\x01\x02\x10\x01R\fhashFunction\x12T\n" +
	"\x11maximum_ring_size\x18\x04 \x01(\v2\x1c.google.protobuf.UInt64ValueB\n" +
	"\xfaB\a2\x05\x18\x80\x80\x80\x04R\x0fmaximumRingSize\".\n" +
	"\fHashFunction\x12\v\n" +
	"\aXX_HASH\x10\x00\x12\x11\n" +
	"\rMURMUR_HASH_2\x10\x01J\x04\b\x02\x10\x03\x1a=\n" +
	"\x13OriginalDstLbConfig\x12&\n" +
	"\x0fuse_http_header\x18\x01 \x01(\bR\ruseHttpHeader\x1a\x86\b\n" +
	"\x0eCommonLbConfig\x12K\n" +
	"\x17healthy_panic_threshold\x18\x01 \x01(\v2\x13.envoy.type.PercentR\x15healthyPanicThreshold\x12i\n" +
	"\x14zone_aware_lb_config\x18\x02 \x01(\v26.envoy.api.v2.Cluster.CommonLbConfig.ZoneAwareLbConfigH\x00R\x11zoneAwareLbConfig\x12~\n" +
	"\x1blocality_weighted_lb_config\x18\x03 \x01(\v2=.envoy.api.v2.Cluster.CommonLbConfig.LocalityWeightedLbConfigH\x00R\x18localityWeightedLbConfig\x12I\n" +
	"\x13update_merge_window\x18\x04 \x01(\v2\x19.google.protobuf.DurationR\x11updateMergeWindow\x12C\n" +
	"\x1fignore_new_hosts_until_first_hc\x18\x05 \x01(\bR\x1aignoreNewHostsUntilFirstHc\x12M\n" +
	"$close_connections_on_host_set_change\x18\x06 \x01(\bR\x1fcloseConnectionsOnHostSetChange\x12\x7f\n" +
	"\x1cconsistent_hashing_lb_config\x18\a \x01(\v2>.envoy.api.v2.Cluster.CommonLbConfig.ConsistentHashingLbConfigR\x19consistentHashingLbConfig\x1a\xcc\x01\n" +
	"\x11ZoneAwareLbConfig\x12<\n" +
	"\x0frouting_enabled\x18\x01 \x01(\v2\x13.envoy.type.PercentR\x0eroutingEnabled\x12F\n" +
	"\x10min_cluster_size\x18\x02 \x01(\v2\x1c.google.protobuf.UInt64ValueR\x0eminClusterSize\x121\n" +
	"\x15fail_traffic_on_panic\x18\x03 \x01(\bR\x12failTrafficOnPanic\x1a\x1a\n" +
	"\x18LocalityWeightedLbConfig\x1aT\n" +
	"\x19ConsistentHashingLbConfig\x127\n" +
	"\x18use_hostname_for_hashing\x18\x01 \x01(\bR\x15useHostnameForHashingB\x1b\n" +
	"\x19locality_config_specifier\x1a\xa9\x01\n" +
	"\vRefreshRate\x12N\n" +
	"\rbase_interval\x18\x01 \x01(\v2\x19.google.protobuf.DurationB\x0e\xfaB\v\xaa\x01\b\b\x01*\x04\x10\xc0\x84=R\fbaseInterval\x12J\n" +
	"\fmax_interval\x18\x02 \x01(\v2\x19.google.protobuf.DurationB\f\xfaB\t\xaa\x01\x06*\x04\x10\xc0\x84=R\vmaxInterval\x1ad\n" +
	"\x1dExtensionProtocolOptionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12-\n" +
	"\x05value\x18\x02 \x01(\v2\x17.google.protobuf.StructR\x05value:\x028\x01\x1af\n" +
	"\"TypedExtensionProtocolOptionsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12*\n" +
	"\x05value\x18\x02 \x01(\v2\x14.google.protobuf.AnyR\x05value:\x028\x01\"W\n" +
	"\rDiscoveryType\x12\n" +
	"\n" +
	"\x06STATIC\x10\x00\x12\x0e\n" +
	"\n" +
	"STRICT_DNS\x10\x01\x12\x0f\n" +
	"\vLOGICAL_DNS\x10\x02\x12\a\n" +
	"\x03EDS\x10\x03\x12\x10\n" +
	"\fORIGINAL_DST\x10\x04\"\xac\x01\n" +
	"\bLbPolicy\x12\x0f\n" +
	"\vROUND_ROBIN\x10\x00\x12\x11\n" +
	"\rLEAST_REQUEST\x10\x01\x12\r\n" +
	"\tRING_HASH\x10\x02\x12\n" +
	"\n" +
	"\x06RANDOM\x10\x03\x12\x1d\n" +
	"\x0fORIGINAL_DST_LB\x10\x04\x1a\b\xa8\xf7\xb4\x8b\x02\x01\b\x01\x12\n" +
	"\n" +
	"\x06MAGLEV\x10\x05\x12\x14\n" +
	"\x10CLUSTER_PROVIDED\x10\x06\x12 \n" +
	"\x1cLOAD_BALANCING_POLICY_CONFIG\x10\a\"5\n" +
	"\x0fDnsLookupFamily\x12\b\n" +
	"\x04AUTO\x10\x00\x12\v\n" +
	"\aV4_ONLY\x10\x01\x12\v\n" +
	"\aV6_ONLY\x10\x02\"T\n" +
	"\x18ClusterProtocolSelection\x12\x1b\n" +
	"\x17USE_CONFIGURED_PROTOCOL\x10\x00\x12\x1b\n" +
	"\x17USE_DOWNSTREAM_PROTOCOL\x10\x01B\x18\n" +
	"\x16cluster_discovery_typeB\v\n" +
	"\tlb_configJ\x04\b\f\x10\rJ\x04\b\x0f\x10\x10\"\xe8\x01\n" +
	"\x13LoadBalancingPolicy\x12D\n" +
	"\bpolicies\x18\x01 \x03(\v2(.envoy.api.v2.LoadBalancingPolicy.PolicyR\bpolicies\x1a\x8a\x01\n" +
	"\x06Policy\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x123\n" +
	"\x06config\x18\x02 \x01(\v2\x17.google.protobuf.StructB\x02\x18\x01R\x06config\x127\n" +
	"\ftyped_config\x18\x03 \x01(\v2\x14.google.protobuf.AnyR\vtypedConfig\"W\n" +
	"\x12UpstreamBindConfig\x12A\n" +
	"\x0esource_address\x18\x01 \x01(\v2\x1a.envoy.api.v2.core.AddressR\rsourceAddress\"a\n" +
	"\x19UpstreamConnectionOptions\x12D\n" +
	"\rtcp_keepalive\x18\x01 \x01(\v2\x1f.envoy.api.v2.core.TcpKeepaliveR\ftcpKeepaliveB\x8e\x01\xf2\x98\xfe\x8f\x05\x19\x12\x17envoy.config.cluster.v3\xba\x80\xc8\xd1\x06\x02\x10\x01\n" +
	"\x1aio.envoyproxy.envoy.api.v2B\fClusterProtoP\x01Z9github.com/envoyproxy/go-control-plane/envoy/api/v2;apiv2b\x06proto3"

var (
	file_envoy_api_v2_cluster_proto_rawDescOnce sync.Once
	file_envoy_api_v2_cluster_proto_rawDescData []byte
)

func file_envoy_api_v2_cluster_proto_rawDescGZIP() []byte {
	file_envoy_api_v2_cluster_proto_rawDescOnce.Do(func() {
		file_envoy_api_v2_cluster_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_envoy_api_v2_cluster_proto_rawDesc), len(file_envoy_api_v2_cluster_proto_rawDesc)))
	})
	return file_envoy_api_v2_cluster_proto_rawDescData
}

var file_envoy_api_v2_cluster_proto_enumTypes = make([]protoimpl.EnumInfo, 7)
var file_envoy_api_v2_cluster_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_envoy_api_v2_cluster_proto_goTypes = []any{
	(Cluster_DiscoveryType)(0),                                                  // 0: envoy.api.v2.Cluster.DiscoveryType
	(Cluster_LbPolicy)(0),                                                       // 1: envoy.api.v2.Cluster.LbPolicy
	(Cluster_DnsLookupFamily)(0),                                                // 2: envoy.api.v2.Cluster.DnsLookupFamily
	(Cluster_ClusterProtocolSelection)(0),                                       // 3: envoy.api.v2.Cluster.ClusterProtocolSelection
	(Cluster_LbSubsetConfig_LbSubsetFallbackPolicy)(0),                          // 4: envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy
	(Cluster_LbSubsetConfig_LbSubsetSelector_LbSubsetSelectorFallbackPolicy)(0), // 5: envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector.LbSubsetSelectorFallbackPolicy
	(Cluster_RingHashLbConfig_HashFunction)(0),                                  // 6: envoy.api.v2.Cluster.RingHashLbConfig.HashFunction
	(*Cluster)(nil),                                                             // 7: envoy.api.v2.Cluster
	(*LoadBalancingPolicy)(nil),                                                 // 8: envoy.api.v2.LoadBalancingPolicy
	(*UpstreamBindConfig)(nil),                                                  // 9: envoy.api.v2.UpstreamBindConfig
	(*UpstreamConnectionOptions)(nil),                                           // 10: envoy.api.v2.UpstreamConnectionOptions
	(*Cluster_TransportSocketMatch)(nil),                                        // 11: envoy.api.v2.Cluster.TransportSocketMatch
	(*Cluster_CustomClusterType)(nil),                                           // 12: envoy.api.v2.Cluster.CustomClusterType
	(*Cluster_EdsClusterConfig)(nil),                                            // 13: envoy.api.v2.Cluster.EdsClusterConfig
	(*Cluster_LbSubsetConfig)(nil),                                              // 14: envoy.api.v2.Cluster.LbSubsetConfig
	(*Cluster_LeastRequestLbConfig)(nil),                                        // 15: envoy.api.v2.Cluster.LeastRequestLbConfig
	(*Cluster_RingHashLbConfig)(nil),                                            // 16: envoy.api.v2.Cluster.RingHashLbConfig
	(*Cluster_OriginalDstLbConfig)(nil),                                         // 17: envoy.api.v2.Cluster.OriginalDstLbConfig
	(*Cluster_CommonLbConfig)(nil),                                              // 18: envoy.api.v2.Cluster.CommonLbConfig
	(*Cluster_RefreshRate)(nil),                                                 // 19: envoy.api.v2.Cluster.RefreshRate
	nil,                                                                         // 20: envoy.api.v2.Cluster.ExtensionProtocolOptionsEntry
	nil,                                                                         // 21: envoy.api.v2.Cluster.TypedExtensionProtocolOptionsEntry
	(*Cluster_LbSubsetConfig_LbSubsetSelector)(nil),                             // 22: envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector
	(*Cluster_CommonLbConfig_ZoneAwareLbConfig)(nil),                            // 23: envoy.api.v2.Cluster.CommonLbConfig.ZoneAwareLbConfig
	(*Cluster_CommonLbConfig_LocalityWeightedLbConfig)(nil),                     // 24: envoy.api.v2.Cluster.CommonLbConfig.LocalityWeightedLbConfig
	(*Cluster_CommonLbConfig_ConsistentHashingLbConfig)(nil),                    // 25: envoy.api.v2.Cluster.CommonLbConfig.ConsistentHashingLbConfig
	(*LoadBalancingPolicy_Policy)(nil),                                          // 26: envoy.api.v2.LoadBalancingPolicy.Policy
	(*durationpb.Duration)(nil),                                                 // 27: google.protobuf.Duration
	(*wrapperspb.UInt32Value)(nil),                                              // 28: google.protobuf.UInt32Value
	(*core.Address)(nil),                                                        // 29: envoy.api.v2.core.Address
	(*ClusterLoadAssignment)(nil),                                               // 30: envoy.api.v2.ClusterLoadAssignment
	(*core.HealthCheck)(nil),                                                    // 31: envoy.api.v2.core.HealthCheck
	(*cluster.CircuitBreakers)(nil),                                             // 32: envoy.api.v2.cluster.CircuitBreakers
	(*auth.UpstreamTlsContext)(nil),                                             // 33: envoy.api.v2.auth.UpstreamTlsContext
	(*core.UpstreamHttpProtocolOptions)(nil),                                    // 34: envoy.api.v2.core.UpstreamHttpProtocolOptions
	(*core.HttpProtocolOptions)(nil),                                            // 35: envoy.api.v2.core.HttpProtocolOptions
	(*core.Http1ProtocolOptions)(nil),                                           // 36: envoy.api.v2.core.Http1ProtocolOptions
	(*core.Http2ProtocolOptions)(nil),                                           // 37: envoy.api.v2.core.Http2ProtocolOptions
	(*cluster.OutlierDetection)(nil),                                            // 38: envoy.api.v2.cluster.OutlierDetection
	(*core.BindConfig)(nil),                                                     // 39: envoy.api.v2.core.BindConfig
	(*core.TransportSocket)(nil),                                                // 40: envoy.api.v2.core.TransportSocket
	(*core.Metadata)(nil),                                                       // 41: envoy.api.v2.core.Metadata
	(*cluster.Filter)(nil),                                                      // 42: envoy.api.v2.cluster.Filter
	(*core.ConfigSource)(nil),                                                   // 43: envoy.api.v2.core.ConfigSource
	(*core.TcpKeepalive)(nil),                                                   // 44: envoy.api.v2.core.TcpKeepalive
	(*structpb.Struct)(nil),                                                     // 45: google.protobuf.Struct
	(*anypb.Any)(nil),                                                           // 46: google.protobuf.Any
	(*wrapperspb.UInt64Value)(nil),                                              // 47: google.protobuf.UInt64Value
	(*_type.Percent)(nil),                                                       // 48: envoy.type.Percent
}
var file_envoy_api_v2_cluster_proto_depIdxs = []int32{
	11, // 0: envoy.api.v2.Cluster.transport_socket_matches:type_name -> envoy.api.v2.Cluster.TransportSocketMatch
	0,  // 1: envoy.api.v2.Cluster.type:type_name -> envoy.api.v2.Cluster.DiscoveryType
	12, // 2: envoy.api.v2.Cluster.cluster_type:type_name -> envoy.api.v2.Cluster.CustomClusterType
	13, // 3: envoy.api.v2.Cluster.eds_cluster_config:type_name -> envoy.api.v2.Cluster.EdsClusterConfig
	27, // 4: envoy.api.v2.Cluster.connect_timeout:type_name -> google.protobuf.Duration
	28, // 5: envoy.api.v2.Cluster.per_connection_buffer_limit_bytes:type_name -> google.protobuf.UInt32Value
	1,  // 6: envoy.api.v2.Cluster.lb_policy:type_name -> envoy.api.v2.Cluster.LbPolicy
	29, // 7: envoy.api.v2.Cluster.hosts:type_name -> envoy.api.v2.core.Address
	30, // 8: envoy.api.v2.Cluster.load_assignment:type_name -> envoy.api.v2.ClusterLoadAssignment
	31, // 9: envoy.api.v2.Cluster.health_checks:type_name -> envoy.api.v2.core.HealthCheck
	28, // 10: envoy.api.v2.Cluster.max_requests_per_connection:type_name -> google.protobuf.UInt32Value
	32, // 11: envoy.api.v2.Cluster.circuit_breakers:type_name -> envoy.api.v2.cluster.CircuitBreakers
	33, // 12: envoy.api.v2.Cluster.tls_context:type_name -> envoy.api.v2.auth.UpstreamTlsContext
	34, // 13: envoy.api.v2.Cluster.upstream_http_protocol_options:type_name -> envoy.api.v2.core.UpstreamHttpProtocolOptions
	35, // 14: envoy.api.v2.Cluster.common_http_protocol_options:type_name -> envoy.api.v2.core.HttpProtocolOptions
	36, // 15: envoy.api.v2.Cluster.http_protocol_options:type_name -> envoy.api.v2.core.Http1ProtocolOptions
	37, // 16: envoy.api.v2.Cluster.http2_protocol_options:type_name -> envoy.api.v2.core.Http2ProtocolOptions
	20, // 17: envoy.api.v2.Cluster.extension_protocol_options:type_name -> envoy.api.v2.Cluster.ExtensionProtocolOptionsEntry
	21, // 18: envoy.api.v2.Cluster.typed_extension_protocol_options:type_name -> envoy.api.v2.Cluster.TypedExtensionProtocolOptionsEntry
	27, // 19: envoy.api.v2.Cluster.dns_refresh_rate:type_name -> google.protobuf.Duration
	19, // 20: envoy.api.v2.Cluster.dns_failure_refresh_rate:type_name -> envoy.api.v2.Cluster.RefreshRate
	2,  // 21: envoy.api.v2.Cluster.dns_lookup_family:type_name -> envoy.api.v2.Cluster.DnsLookupFamily
	29, // 22: envoy.api.v2.Cluster.dns_resolvers:type_name -> envoy.api.v2.core.Address
	38, // 23: envoy.api.v2.Cluster.outlier_detection:type_name -> envoy.api.v2.cluster.OutlierDetection
	27, // 24: envoy.api.v2.Cluster.cleanup_interval:type_name -> google.protobuf.Duration
	39, // 25: envoy.api.v2.Cluster.upstream_bind_config:type_name -> envoy.api.v2.core.BindConfig
	14, // 26: envoy.api.v2.Cluster.lb_subset_config:type_name -> envoy.api.v2.Cluster.LbSubsetConfig
	16, // 27: envoy.api.v2.Cluster.ring_hash_lb_config:type_name -> envoy.api.v2.Cluster.RingHashLbConfig
	17, // 28: envoy.api.v2.Cluster.original_dst_lb_config:type_name -> envoy.api.v2.Cluster.OriginalDstLbConfig
	15, // 29: envoy.api.v2.Cluster.least_request_lb_config:type_name -> envoy.api.v2.Cluster.LeastRequestLbConfig
	18, // 30: envoy.api.v2.Cluster.common_lb_config:type_name -> envoy.api.v2.Cluster.CommonLbConfig
	40, // 31: envoy.api.v2.Cluster.transport_socket:type_name -> envoy.api.v2.core.TransportSocket
	41, // 32: envoy.api.v2.Cluster.metadata:type_name -> envoy.api.v2.core.Metadata
	3,  // 33: envoy.api.v2.Cluster.protocol_selection:type_name -> envoy.api.v2.Cluster.ClusterProtocolSelection
	10, // 34: envoy.api.v2.Cluster.upstream_connection_options:type_name -> envoy.api.v2.UpstreamConnectionOptions
	42, // 35: envoy.api.v2.Cluster.filters:type_name -> envoy.api.v2.cluster.Filter
	8,  // 36: envoy.api.v2.Cluster.load_balancing_policy:type_name -> envoy.api.v2.LoadBalancingPolicy
	43, // 37: envoy.api.v2.Cluster.lrs_server:type_name -> envoy.api.v2.core.ConfigSource
	26, // 38: envoy.api.v2.LoadBalancingPolicy.policies:type_name -> envoy.api.v2.LoadBalancingPolicy.Policy
	29, // 39: envoy.api.v2.UpstreamBindConfig.source_address:type_name -> envoy.api.v2.core.Address
	44, // 40: envoy.api.v2.UpstreamConnectionOptions.tcp_keepalive:type_name -> envoy.api.v2.core.TcpKeepalive
	45, // 41: envoy.api.v2.Cluster.TransportSocketMatch.match:type_name -> google.protobuf.Struct
	40, // 42: envoy.api.v2.Cluster.TransportSocketMatch.transport_socket:type_name -> envoy.api.v2.core.TransportSocket
	46, // 43: envoy.api.v2.Cluster.CustomClusterType.typed_config:type_name -> google.protobuf.Any
	43, // 44: envoy.api.v2.Cluster.EdsClusterConfig.eds_config:type_name -> envoy.api.v2.core.ConfigSource
	4,  // 45: envoy.api.v2.Cluster.LbSubsetConfig.fallback_policy:type_name -> envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetFallbackPolicy
	45, // 46: envoy.api.v2.Cluster.LbSubsetConfig.default_subset:type_name -> google.protobuf.Struct
	22, // 47: envoy.api.v2.Cluster.LbSubsetConfig.subset_selectors:type_name -> envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector
	28, // 48: envoy.api.v2.Cluster.LeastRequestLbConfig.choice_count:type_name -> google.protobuf.UInt32Value
	47, // 49: envoy.api.v2.Cluster.RingHashLbConfig.minimum_ring_size:type_name -> google.protobuf.UInt64Value
	6,  // 50: envoy.api.v2.Cluster.RingHashLbConfig.hash_function:type_name -> envoy.api.v2.Cluster.RingHashLbConfig.HashFunction
	47, // 51: envoy.api.v2.Cluster.RingHashLbConfig.maximum_ring_size:type_name -> google.protobuf.UInt64Value
	48, // 52: envoy.api.v2.Cluster.CommonLbConfig.healthy_panic_threshold:type_name -> envoy.type.Percent
	23, // 53: envoy.api.v2.Cluster.CommonLbConfig.zone_aware_lb_config:type_name -> envoy.api.v2.Cluster.CommonLbConfig.ZoneAwareLbConfig
	24, // 54: envoy.api.v2.Cluster.CommonLbConfig.locality_weighted_lb_config:type_name -> envoy.api.v2.Cluster.CommonLbConfig.LocalityWeightedLbConfig
	27, // 55: envoy.api.v2.Cluster.CommonLbConfig.update_merge_window:type_name -> google.protobuf.Duration
	25, // 56: envoy.api.v2.Cluster.CommonLbConfig.consistent_hashing_lb_config:type_name -> envoy.api.v2.Cluster.CommonLbConfig.ConsistentHashingLbConfig
	27, // 57: envoy.api.v2.Cluster.RefreshRate.base_interval:type_name -> google.protobuf.Duration
	27, // 58: envoy.api.v2.Cluster.RefreshRate.max_interval:type_name -> google.protobuf.Duration
	45, // 59: envoy.api.v2.Cluster.ExtensionProtocolOptionsEntry.value:type_name -> google.protobuf.Struct
	46, // 60: envoy.api.v2.Cluster.TypedExtensionProtocolOptionsEntry.value:type_name -> google.protobuf.Any
	5,  // 61: envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector.fallback_policy:type_name -> envoy.api.v2.Cluster.LbSubsetConfig.LbSubsetSelector.LbSubsetSelectorFallbackPolicy
	48, // 62: envoy.api.v2.Cluster.CommonLbConfig.ZoneAwareLbConfig.routing_enabled:type_name -> envoy.type.Percent
	47, // 63: envoy.api.v2.Cluster.CommonLbConfig.ZoneAwareLbConfig.min_cluster_size:type_name -> google.protobuf.UInt64Value
	45, // 64: envoy.api.v2.LoadBalancingPolicy.Policy.config:type_name -> google.protobuf.Struct
	46, // 65: envoy.api.v2.LoadBalancingPolicy.Policy.typed_config:type_name -> google.protobuf.Any
	66, // [66:66] is the sub-list for method output_type
	66, // [66:66] is the sub-list for method input_type
	66, // [66:66] is the sub-list for extension type_name
	66, // [66:66] is the sub-list for extension extendee
	0,  // [0:66] is the sub-list for field type_name
}

func init() { file_envoy_api_v2_cluster_proto_init() }
func file_envoy_api_v2_cluster_proto_init() {
	if File_envoy_api_v2_cluster_proto != nil {
		return
	}
	file_envoy_api_v2_endpoint_proto_init()
	file_envoy_api_v2_cluster_proto_msgTypes[0].OneofWrappers = []any{
		(*Cluster_Type)(nil),
		(*Cluster_ClusterType)(nil),
		(*Cluster_RingHashLbConfig_)(nil),
		(*Cluster_OriginalDstLbConfig_)(nil),
		(*Cluster_LeastRequestLbConfig_)(nil),
	}
	file_envoy_api_v2_cluster_proto_msgTypes[11].OneofWrappers = []any{
		(*Cluster_CommonLbConfig_ZoneAwareLbConfig_)(nil),
		(*Cluster_CommonLbConfig_LocalityWeightedLbConfig_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_envoy_api_v2_cluster_proto_rawDesc), len(file_envoy_api_v2_cluster_proto_rawDesc)),
			NumEnums:      7,
			NumMessages:   20,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_envoy_api_v2_cluster_proto_goTypes,
		DependencyIndexes: file_envoy_api_v2_cluster_proto_depIdxs,
		EnumInfos:         file_envoy_api_v2_cluster_proto_enumTypes,
		MessageInfos:      file_envoy_api_v2_cluster_proto_msgTypes,
	}.Build()
	File_envoy_api_v2_cluster_proto = out.File
	file_envoy_api_v2_cluster_proto_goTypes = nil
	file_envoy_api_v2_cluster_proto_depIdxs = nil
}