// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.33.2
// source: envoy/extensions/load_balancing_policies/common/v3/common.proto

package commonv3

import (
	_ "github.com/cncf/xds/go/udpa/annotations"
	_ "github.com/envoyproxy/go-control-plane/envoy/annotations"
	v3 "github.com/envoyproxy/go-control-plane/envoy/config/core/v3"
	v32 "github.com/envoyproxy/go-control-plane/envoy/config/route/v3"
	v31 "github.com/envoyproxy/go-control-plane/envoy/type/v3"
	_ "github.com/envoyproxy/protoc-gen-validate/validate"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	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)
)

// Basis for computing per-locality percentages in zone-aware routing.
type LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis int32

const (
	// Use the number of healthy hosts in each locality.
	LocalityLbConfig_ZoneAwareLbConfig_HEALTHY_HOSTS_NUM LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis = 0
	// Use the weights of healthy hosts in each locality.
	LocalityLbConfig_ZoneAwareLbConfig_HEALTHY_HOSTS_WEIGHT LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis = 1
)

// Enum value maps for LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis.
var (
	LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis_name = map[int32]string{
		0: "HEALTHY_HOSTS_NUM",
		1: "HEALTHY_HOSTS_WEIGHT",
	}
	LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis_value = map[string]int32{
		"HEALTHY_HOSTS_NUM":    0,
		"HEALTHY_HOSTS_WEIGHT": 1,
	}
)

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

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

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Descriptor() protoreflect.EnumDescriptor {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_enumTypes[0].Descriptor()
}

func (LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis) Type() protoreflect.EnumType {
	return &file_envoy_extensions_load_balancing_policies_common_v3_common_proto_enumTypes[0]
}

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

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

type LocalityLbConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to LocalityConfigSpecifier:
	//
	//	*LocalityLbConfig_ZoneAwareLbConfig_
	//	*LocalityLbConfig_LocalityWeightedLbConfig_
	LocalityConfigSpecifier isLocalityLbConfig_LocalityConfigSpecifier `protobuf_oneof:"locality_config_specifier"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

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

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

func (*LocalityLbConfig) ProtoMessage() {}

func (x *LocalityLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_load_balancing_policies_common_v3_common_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 LocalityLbConfig.ProtoReflect.Descriptor instead.
func (*LocalityLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP(), []int{0}
}

func (x *LocalityLbConfig) GetLocalityConfigSpecifier() isLocalityLbConfig_LocalityConfigSpecifier {
	if x != nil {
		return x.LocalityConfigSpecifier
	}
	return nil
}

func (x *LocalityLbConfig) GetZoneAwareLbConfig() *LocalityLbConfig_ZoneAwareLbConfig {
	if x != nil {
		if x, ok := x.LocalityConfigSpecifier.(*LocalityLbConfig_ZoneAwareLbConfig_); ok {
			return x.ZoneAwareLbConfig
		}
	}
	return nil
}

func (x *LocalityLbConfig) GetLocalityWeightedLbConfig() *LocalityLbConfig_LocalityWeightedLbConfig {
	if x != nil {
		if x, ok := x.LocalityConfigSpecifier.(*LocalityLbConfig_LocalityWeightedLbConfig_); ok {
			return x.LocalityWeightedLbConfig
		}
	}
	return nil
}

type isLocalityLbConfig_LocalityConfigSpecifier interface {
	isLocalityLbConfig_LocalityConfigSpecifier()
}

type LocalityLbConfig_ZoneAwareLbConfig_ struct {
	// Configuration for local zone aware load balancing.
	ZoneAwareLbConfig *LocalityLbConfig_ZoneAwareLbConfig `protobuf:"bytes,1,opt,name=zone_aware_lb_config,json=zoneAwareLbConfig,proto3,oneof"`
}

type LocalityLbConfig_LocalityWeightedLbConfig_ struct {
	// Enable locality weighted load balancing.
	LocalityWeightedLbConfig *LocalityLbConfig_LocalityWeightedLbConfig `protobuf:"bytes,2,opt,name=locality_weighted_lb_config,json=localityWeightedLbConfig,proto3,oneof"`
}

func (*LocalityLbConfig_ZoneAwareLbConfig_) isLocalityLbConfig_LocalityConfigSpecifier() {}

func (*LocalityLbConfig_LocalityWeightedLbConfig_) isLocalityLbConfig_LocalityConfigSpecifier() {}

// Configuration for :ref:`slow start mode <arch_overview_load_balancing_slow_start>`.
type SlowStartConfig struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Represents the size of slow start window.
	// If set, the newly created host remains in slow start mode starting from its creation time
	// for the duration of slow start window.
	SlowStartWindow *durationpb.Duration `protobuf:"bytes,1,opt,name=slow_start_window,json=slowStartWindow,proto3" json:"slow_start_window,omitempty"`
	// This parameter controls the speed of traffic increase over the slow start window. Defaults to 1.0,
	// so that endpoint would get linearly increasing amount of traffic.
	// When increasing the value for this parameter, the speed of traffic ramp-up increases non-linearly.
	// The value of aggression parameter should be greater than 0.0.
	// By tuning the parameter, is possible to achieve polynomial or exponential shape of ramp-up curve.
	//
	// During slow start window, effective weight of an endpoint would be scaled with time factor and aggression:
	// “new_weight = weight * max(min_weight_percent, time_factor ^ (1 / aggression))“,
	// where “time_factor=(time_since_start_seconds / slow_start_time_seconds)“.
	//
	// As time progresses, more and more traffic would be sent to endpoint, which is in slow start window.
	// Once host exits slow start, time_factor and aggression no longer affect its weight.
	Aggression *v3.RuntimeDouble `protobuf:"bytes,2,opt,name=aggression,proto3" json:"aggression,omitempty"`
	// Configures the minimum percentage of origin weight that avoids too small new weight,
	// which may cause endpoints in slow start mode receive no traffic in slow start window.
	// If not specified, the default is 10%.
	MinWeightPercent *v31.Percent `protobuf:"bytes,3,opt,name=min_weight_percent,json=minWeightPercent,proto3" json:"min_weight_percent,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*SlowStartConfig) ProtoMessage() {}

func (x *SlowStartConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_load_balancing_policies_common_v3_common_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 SlowStartConfig.ProtoReflect.Descriptor instead.
func (*SlowStartConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP(), []int{1}
}

func (x *SlowStartConfig) GetSlowStartWindow() *durationpb.Duration {
	if x != nil {
		return x.SlowStartWindow
	}
	return nil
}

func (x *SlowStartConfig) GetAggression() *v3.RuntimeDouble {
	if x != nil {
		return x.Aggression
	}
	return nil
}

func (x *SlowStartConfig) GetMinWeightPercent() *v31.Percent {
	if x != nil {
		return x.MinWeightPercent
	}
	return nil
}

// Common Configuration for all consistent hashing load balancers (MaglevLb, RingHashLb, etc.)
type 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"`
	// Configures percentage of average cluster load to bound per upstream host. For example, with a value of 150
	// no upstream host will get a load more than 1.5 times the average load of all the hosts in the cluster.
	// If not specified, the load is not bounded for any upstream host. Typical value for this parameter is between 120 and 200.
	// Minimum is 100.
	//
	// Applies to both Ring Hash and Maglev load balancers.
	//
	// This is implemented based on the method described in the paper https://arxiv.org/abs/1608.01350. For the specified
	// “hash_balance_factor“, requests to any upstream host are capped at “hash_balance_factor/100“ times the average number of requests
	// across the cluster. When a request arrives for an upstream host that is currently serving at its max capacity, linear probing
	// is used to identify an eligible host. Further, the linear probe is implemented using a random jump in hosts ring/table to identify
	// the eligible host (this technique is as described in the paper https://arxiv.org/abs/1908.08762 - the random jump avoids the
	// cascading overflow effect when choosing the next host in the ring/table).
	//
	// If weights are specified on the hosts, they are respected.
	//
	// This is an O(N) algorithm, unlike other load balancers. Using a lower “hash_balance_factor“ results in more hosts
	// being probed, so use a higher value if you require better performance.
	HashBalanceFactor *wrapperspb.UInt32Value `protobuf:"bytes,2,opt,name=hash_balance_factor,json=hashBalanceFactor,proto3" json:"hash_balance_factor,omitempty"`
	//	Specifies a list of hash policies to use for ring hash load balancing. If ``hash_policy`` is
	//
	// set, then
	// :ref:`route level hash policy <envoy_v3_api_field_config.route.v3.RouteAction.hash_policy>`
	// will be ignored.
	HashPolicy    []*v32.RouteAction_HashPolicy `protobuf:"bytes,3,rep,name=hash_policy,json=hashPolicy,proto3" json:"hash_policy,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ConsistentHashingLbConfig) ProtoMessage() {}

func (x *ConsistentHashingLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_load_balancing_policies_common_v3_common_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 ConsistentHashingLbConfig.ProtoReflect.Descriptor instead.
func (*ConsistentHashingLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP(), []int{2}
}

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

func (x *ConsistentHashingLbConfig) GetHashBalanceFactor() *wrapperspb.UInt32Value {
	if x != nil {
		return x.HashBalanceFactor
	}
	return nil
}

func (x *ConsistentHashingLbConfig) GetHashPolicy() []*v32.RouteAction_HashPolicy {
	if x != nil {
		return x.HashPolicy
	}
	return nil
}

// Configuration for :ref:`zone aware routing
// <arch_overview_load_balancing_zone_aware_routing>`.
// [#next-free-field: 7]
type LocalityLbConfig_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 *v31.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"`
	// If set to true, Envoy will force LocalityDirect routing if a local locality exists.
	//
	// Deprecated: Marked as deprecated in envoy/extensions/load_balancing_policies/common/v3/common.proto.
	ForceLocalityDirectRouting bool                                               `protobuf:"varint,4,opt,name=force_locality_direct_routing,json=forceLocalityDirectRouting,proto3" json:"force_locality_direct_routing,omitempty"`
	ForceLocalZone             *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone `protobuf:"bytes,5,opt,name=force_local_zone,json=forceLocalZone,proto3" json:"force_local_zone,omitempty"`
	// Determines how locality percentages are computed:
	// - HEALTHY_HOSTS_NUM: proportional to the count of healthy hosts.
	// - HEALTHY_HOSTS_WEIGHT: proportional to the weights of healthy hosts.
	// Default value is HEALTHY_HOSTS_NUM if unset.
	LocalityBasis LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis `protobuf:"varint,6,opt,name=locality_basis,json=localityBasis,proto3,enum=envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis" json:"locality_basis,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LocalityLbConfig_ZoneAwareLbConfig) ProtoMessage() {}

func (x *LocalityLbConfig_ZoneAwareLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_load_balancing_policies_common_v3_common_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 LocalityLbConfig_ZoneAwareLbConfig.ProtoReflect.Descriptor instead.
func (*LocalityLbConfig_ZoneAwareLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP(), []int{0, 0}
}

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

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

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

// Deprecated: Marked as deprecated in envoy/extensions/load_balancing_policies/common/v3/common.proto.
func (x *LocalityLbConfig_ZoneAwareLbConfig) GetForceLocalityDirectRouting() bool {
	if x != nil {
		return x.ForceLocalityDirectRouting
	}
	return false
}

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetForceLocalZone() *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone {
	if x != nil {
		return x.ForceLocalZone
	}
	return nil
}

func (x *LocalityLbConfig_ZoneAwareLbConfig) GetLocalityBasis() LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis {
	if x != nil {
		return x.LocalityBasis
	}
	return LocalityLbConfig_ZoneAwareLbConfig_HEALTHY_HOSTS_NUM
}

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

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

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

func (*LocalityLbConfig_LocalityWeightedLbConfig) ProtoMessage() {}

func (x *LocalityLbConfig_LocalityWeightedLbConfig) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_load_balancing_policies_common_v3_common_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 LocalityLbConfig_LocalityWeightedLbConfig.ProtoReflect.Descriptor instead.
func (*LocalityLbConfig_LocalityWeightedLbConfig) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP(), []int{0, 1}
}

// Configures Envoy to always route requests to the local zone regardless of the
// upstream zone structure. In Envoy's default configuration, traffic is distributed proportionally
// across all upstream hosts while trying to maximize local routing when possible. The approach
// with force_local_zone aims to be more predictable and if there are upstream hosts in the local
// zone, they will receive all traffic.
// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
type LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Configures the minimum number of upstream hosts in the local zone required when force_local_zone
	// is enabled. If the number of upstream hosts in the local zone is less than the specified value,
	// Envoy will fall back to the default proportional-based distribution across localities.
	// If not specified, the default is 1.
	// * :ref:`runtime values <config_cluster_manager_cluster_runtime_zone_routing>`.
	// * :ref:`Zone aware routing support <arch_overview_load_balancing_zone_aware_routing>`.
	MinSize       *wrapperspb.UInt32Value `protobuf:"bytes,1,opt,name=min_size,json=minSize,proto3" json:"min_size,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ProtoMessage() {}

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) ProtoReflect() protoreflect.Message {
	mi := &file_envoy_extensions_load_balancing_policies_common_v3_common_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 LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone.ProtoReflect.Descriptor instead.
func (*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) Descriptor() ([]byte, []int) {
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP(), []int{0, 0, 0}
}

func (x *LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone) GetMinSize() *wrapperspb.UInt32Value {
	if x != nil {
		return x.MinSize
	}
	return nil
}

var File_envoy_extensions_load_balancing_policies_common_v3_common_proto protoreflect.FileDescriptor

const file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDesc = "" +
	"\n" +
	"?envoy/extensions/load_balancing_policies/common/v3/common.proto\x122envoy.extensions.load_balancing_policies.common.v3\x1a\x1fenvoy/config/core/v3/base.proto\x1a,envoy/config/route/v3/route_components.proto\x1a\x1benvoy/type/v3/percent.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a#envoy/annotations/deprecation.proto\x1a\x1dudpa/annotations/status.proto\x1a\x17validate/validate.proto\"\xcc\b\n" +
	"\x10LocalityLbConfig\x12\x89\x01\n" +
	"\x14zone_aware_lb_config\x18\x01 \x01(\v2V.envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfigH\x00R\x11zoneAwareLbConfig\x12\x9e\x01\n" +
	"\x1blocality_weighted_lb_config\x18\x02 \x01(\v2].envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.LocalityWeightedLbConfigH\x00R\x18localityWeightedLbConfig\x1a\xcc\x05\n" +
	"\x11ZoneAwareLbConfig\x12?\n" +
	"\x0frouting_enabled\x18\x01 \x01(\v2\x16.envoy.type.v3.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\x12N\n" +
	"\x1dforce_locality_direct_routing\x18\x04 \x01(\bB\v\x92ǆ\xd8\x04\x033.0\x18\x01R\x1aforceLocalityDirectRouting\x12\x8f\x01\n" +
	"\x10force_local_zone\x18\x05 \x01(\v2e.envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.ForceLocalZoneR\x0eforceLocalZone\x12\x8b\x01\n" +
	"\x0elocality_basis\x18\x06 \x01(\x0e2d.envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.LocalityBasisR\rlocalityBasis\x1aI\n" +
	"\x0eForceLocalZone\x127\n" +
	"\bmin_size\x18\x01 \x01(\v2\x1c.google.protobuf.UInt32ValueR\aminSize\"@\n" +
	"\rLocalityBasis\x12\x15\n" +
	"\x11HEALTHY_HOSTS_NUM\x10\x00\x12\x18\n" +
	"\x14HEALTHY_HOSTS_WEIGHT\x10\x01\x1a\x1a\n" +
	"\x18LocalityWeightedLbConfigB \n" +
	"\x19locality_config_specifier\x12\x03\xf8B\x01\"\xe3\x01\n" +
	"\x0fSlowStartConfig\x12E\n" +
	"\x11slow_start_window\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\x0fslowStartWindow\x12C\n" +
	"\n" +
	"aggression\x18\x02 \x01(\v2#.envoy.config.core.v3.RuntimeDoubleR\n" +
	"aggression\x12D\n" +
	"\x12min_weight_percent\x18\x03 \x01(\v2\x16.envoy.type.v3.PercentR\x10minWeightPercent\"\xfb\x01\n" +
	"\x19ConsistentHashingLbConfig\x127\n" +
	"\x18use_hostname_for_hashing\x18\x01 \x01(\bR\x15useHostnameForHashing\x12U\n" +
	"\x13hash_balance_factor\x18\x02 \x01(\v2\x1c.google.protobuf.UInt32ValueB\a\xfaB\x04*\x02(dR\x11hashBalanceFactor\x12N\n" +
	"\vhash_policy\x18\x03 \x03(\v2-.envoy.config.route.v3.RouteAction.HashPolicyR\n" +
	"hashPolicyB\xbd\x01\xba\x80\xc8\xd1\x06\x02\x10\x02\n" +
	"@io.envoyproxy.envoy.extensions.load_balancing_policies.common.v3B\vCommonProtoP\x01Zbgithub.com/envoyproxy/go-control-plane/envoy/extensions/load_balancing_policies/common/v3;commonv3b\x06proto3"

var (
	file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescOnce sync.Once
	file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescData []byte
)

func file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescGZIP() []byte {
	file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescOnce.Do(func() {
		file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDesc), len(file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDesc)))
	})
	return file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDescData
}

var file_envoy_extensions_load_balancing_policies_common_v3_common_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_envoy_extensions_load_balancing_policies_common_v3_common_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_envoy_extensions_load_balancing_policies_common_v3_common_proto_goTypes = []any{
	(LocalityLbConfig_ZoneAwareLbConfig_LocalityBasis)(0),     // 0: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.LocalityBasis
	(*LocalityLbConfig)(nil),                                  // 1: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig
	(*SlowStartConfig)(nil),                                   // 2: envoy.extensions.load_balancing_policies.common.v3.SlowStartConfig
	(*ConsistentHashingLbConfig)(nil),                         // 3: envoy.extensions.load_balancing_policies.common.v3.ConsistentHashingLbConfig
	(*LocalityLbConfig_ZoneAwareLbConfig)(nil),                // 4: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig
	(*LocalityLbConfig_LocalityWeightedLbConfig)(nil),         // 5: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.LocalityWeightedLbConfig
	(*LocalityLbConfig_ZoneAwareLbConfig_ForceLocalZone)(nil), // 6: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.ForceLocalZone
	(*durationpb.Duration)(nil),                               // 7: google.protobuf.Duration
	(*v3.RuntimeDouble)(nil),                                  // 8: envoy.config.core.v3.RuntimeDouble
	(*v31.Percent)(nil),                                       // 9: envoy.type.v3.Percent
	(*wrapperspb.UInt32Value)(nil),                            // 10: google.protobuf.UInt32Value
	(*v32.RouteAction_HashPolicy)(nil),                        // 11: envoy.config.route.v3.RouteAction.HashPolicy
	(*wrapperspb.UInt64Value)(nil),                            // 12: google.protobuf.UInt64Value
}
var file_envoy_extensions_load_balancing_policies_common_v3_common_proto_depIdxs = []int32{
	4,  // 0: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.zone_aware_lb_config:type_name -> envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig
	5,  // 1: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.locality_weighted_lb_config:type_name -> envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.LocalityWeightedLbConfig
	7,  // 2: envoy.extensions.load_balancing_policies.common.v3.SlowStartConfig.slow_start_window:type_name -> google.protobuf.Duration
	8,  // 3: envoy.extensions.load_balancing_policies.common.v3.SlowStartConfig.aggression:type_name -> envoy.config.core.v3.RuntimeDouble
	9,  // 4: envoy.extensions.load_balancing_policies.common.v3.SlowStartConfig.min_weight_percent:type_name -> envoy.type.v3.Percent
	10, // 5: envoy.extensions.load_balancing_policies.common.v3.ConsistentHashingLbConfig.hash_balance_factor:type_name -> google.protobuf.UInt32Value
	11, // 6: envoy.extensions.load_balancing_policies.common.v3.ConsistentHashingLbConfig.hash_policy:type_name -> envoy.config.route.v3.RouteAction.HashPolicy
	9,  // 7: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.routing_enabled:type_name -> envoy.type.v3.Percent
	12, // 8: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.min_cluster_size:type_name -> google.protobuf.UInt64Value
	6,  // 9: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.force_local_zone:type_name -> envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.ForceLocalZone
	0,  // 10: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.locality_basis:type_name -> envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.LocalityBasis
	10, // 11: envoy.extensions.load_balancing_policies.common.v3.LocalityLbConfig.ZoneAwareLbConfig.ForceLocalZone.min_size:type_name -> google.protobuf.UInt32Value
	12, // [12:12] is the sub-list for method output_type
	12, // [12:12] is the sub-list for method input_type
	12, // [12:12] is the sub-list for extension type_name
	12, // [12:12] is the sub-list for extension extendee
	0,  // [0:12] is the sub-list for field type_name
}

func init() { file_envoy_extensions_load_balancing_policies_common_v3_common_proto_init() }
func file_envoy_extensions_load_balancing_policies_common_v3_common_proto_init() {
	if File_envoy_extensions_load_balancing_policies_common_v3_common_proto != nil {
		return
	}
	file_envoy_extensions_load_balancing_policies_common_v3_common_proto_msgTypes[0].OneofWrappers = []any{
		(*LocalityLbConfig_ZoneAwareLbConfig_)(nil),
		(*LocalityLbConfig_LocalityWeightedLbConfig_)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDesc), len(file_envoy_extensions_load_balancing_policies_common_v3_common_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   6,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_envoy_extensions_load_balancing_policies_common_v3_common_proto_goTypes,
		DependencyIndexes: file_envoy_extensions_load_balancing_policies_common_v3_common_proto_depIdxs,
		EnumInfos:         file_envoy_extensions_load_balancing_policies_common_v3_common_proto_enumTypes,
		MessageInfos:      file_envoy_extensions_load_balancing_policies_common_v3_common_proto_msgTypes,
	}.Build()
	File_envoy_extensions_load_balancing_policies_common_v3_common_proto = out.File
	file_envoy_extensions_load_balancing_policies_common_v3_common_proto_goTypes = nil
	file_envoy_extensions_load_balancing_policies_common_v3_common_proto_depIdxs = nil
}
